cobweb-launcher 1.2.25__py3-none-any.whl → 3.2.18__py3-none-any.whl

cobweb/launchers/launcher_api.py

@@ -1,221 +0,0 @@
-import time
-import threading
-
-from cobweb.db import ApiDB
-from cobweb.base import Seed, logger
-from cobweb.constant import DealModel, LogTemplate
-from .launcher import Launcher, check_pause
-
-
-class LauncherApi(Launcher):
-
-    def __init__(self, task, project, custom_setting=None, **kwargs):
-        super().__init__(task, project, custom_setting, **kwargs)
-        self._db = ApiDB()
-
-        self._todo_key = "{%s:%s}:todo" % (project, task)
-        self._done_key = "{%s:%s}:done" % (project, task)
-        self._fail_key = "{%s:%s}:fail" % (project, task)
-        self._heartbeat_key = "heartbeat:%s_%s" % (project, task)
-
-        self._statistics_done_key = "statistics:%s:%s:done" % (project, task)
-        self._statistics_fail_key = "statistics:%s:%s:fail" % (project, task)
-        self._speed_control_key = "speed_control:%s_%s" % (project, task)
-
-        self._reset_lock_key = "lock:reset:%s_%s" % (project, task)
-
-        # self._bf_key = "bloom_%s_%s" % (project, task)
-        # self._bf = BloomFilter(self._bf_key)
-
-        self._heartbeat_start_event = threading.Event()
-        self._redis_queue_empty_event = threading.Event()
-
-    @property
-    def heartbeat(self):
-        return self._db.exists(self._heartbeat_key)
-
-    def statistics(self, key, count):
-        if not self._task_model and not self._db.exists(key):
-            self._db.setex(key, 86400 * 30, int(count))
-        else:
-            self._db.incrby(key, count)
-
-    def _get_seed(self) -> Seed:
-        """
-        从队列中获取种子（频控）
-        设置时间窗口为self._time_window（秒），判断在该窗口内的采集量是否满足阈值（self._spider_max_speed）
-        :return: True -> 种子, False -> None
-        """
-        if (self.__LAUNCHER_QUEUE__["todo"].length and
-                not self._db.auto_incr(self._speed_control_key, t=self._time_window, limit=self._spider_max_count)):
-            expire_time = self._db.ttl(self._speed_control_key)
-            logger.info(f"Too fast! Please wait {expire_time} seconds...")
-            time.sleep(expire_time / 2)
-            return None
-        seed = self.__LAUNCHER_QUEUE__["todo"].pop()
-        return seed
-
-    @check_pause
-    def _execute_heartbeat(self):
-        if self._heartbeat_start_event.is_set():
-            self._db.setex(self._heartbeat_key, 5)
-        time.sleep(3)
-
-    @check_pause
-    def _reset(self):
-        """
-        检查过期种子，重新添加到redis缓存中
-        """
-        reset_wait_seconds = 30
-        if self._db.lock(self._reset_lock_key, t=120):
-
-            _min = -int(time.time()) + self._seed_reset_seconds \
-                if self.heartbeat else "-inf"
-
-            self._db.members(self._todo_key, 0, _min=_min, _max="(0")
-
-            if not self.heartbeat:
-                self._heartbeat_start_event.set()
-
-            self._db.delete(self._reset_lock_key)
-
-        time.sleep(reset_wait_seconds)
-
-    @check_pause
-    def _scheduler(self):
-        """
-        调度任务，获取redis队列种子，同时添加到doing字典中
-        """
-        if not self._db.zcount(self._todo_key, 0, "(1000"):
-            time.sleep(self._scheduler_wait_seconds)
-        elif self.__LAUNCHER_QUEUE__['todo'].length >= self._todo_queue_size:
-            time.sleep(self._todo_queue_full_wait_seconds)
-        else:
-            members = self._db.members(
-                self._todo_key, int(time.time()),
-                count=self._todo_queue_size,
-                _min=0, _max="(1000"
-            )
-            for member, priority in members:
-                seed = Seed(member, priority=priority)
-                self.__LAUNCHER_QUEUE__['todo'].push(seed)
-                self.__DOING__[seed.to_string] = seed.params.priority
-
-    @check_pause
-    def _insert(self):
-        """
-        添加新种子到redis队列中
-        """
-        seeds = {}
-        status = self.__LAUNCHER_QUEUE__['new'].length < self._new_queue_max_size
-        for _ in range(self._new_queue_max_size):
-            seed = self.__LAUNCHER_QUEUE__['new'].pop()
-            if seed:
-                seeds[seed.to_string] = seed.params.priority
-        if seeds:
-            self._db.zadd(self._todo_key, seeds, nx=True)
-        if status:
-            time.sleep(self._new_queue_wait_seconds)
-
-    @check_pause
-    def _refresh(self):
-        """
-        刷新doing种子过期时间，防止reset重新消费
-        """
-        if self.__DOING__:
-            refresh_time = int(time.time())
-            seeds = {k:-refresh_time - v / 1000 for k, v in self.__DOING__.items()}
-            self._db.zadd(self._todo_key, item=seeds, xx=True)
-        time.sleep(15)
-
-    @check_pause
-    def _delete(self):
-        """
-        删除队列种子，根据状态添加至成功或失败队列，移除doing字典种子索引
-        """
-        seed_info = {"count": 0, "failed": [], "succeed": [], "common": []}
-        status = self.__LAUNCHER_QUEUE__['done'].length < self._done_queue_max_size
-
-        for _ in range(self._done_queue_max_size):
-            seed = self.__LAUNCHER_QUEUE__['done'].pop()
-            if not seed:
-                break
-            if seed.params.seed_status == DealModel.fail:
-                seed_info["failed"].append(seed.to_string)
-            elif self._done_model == 1:
-                seed_info["succeed"].append(seed.to_string)
-            else:
-                seed_info["common"].append(seed.to_string)
-            seed_info['count'] += 1
-
-        if seed_info["count"]:
-
-            succeed_count = int(self._db.zrem(self._todo_key, *seed_info["common"]) or 0)
-            succeed_count += int(self._db.done([self._todo_key, self._done_key], *seed_info["succeed"]) or 0)
-            failed_count = int(self._db.done([self._todo_key, self._fail_key], *seed_info["failed"]) or 0)
-
-            if failed_count:
-                self.statistics(self._statistics_fail_key, failed_count)
-            if succeed_count:
-                self.statistics(self._statistics_done_key, succeed_count)
-
-            self._remove_doing_seeds(seed_info["common"] + seed_info["succeed"] + seed_info["failed"])
-
-        if status:
-            time.sleep(self._done_queue_wait_seconds)
-
-    def _polling(self):
-        wait_scheduler_execute = True
-        check_emtpy_times = 0
-        while not self._stop.is_set():
-            queue_not_empty_count = 0
-            pooling_wait_seconds = 30
-
-            for q in self.__LAUNCHER_QUEUE__.values():
-                if q.length != 0:
-                    queue_not_empty_count += 1
-                    wait_scheduler_execute = False
-
-            if queue_not_empty_count == 0:
-                pooling_wait_seconds = 3
-                if self._pause.is_set():
-                    check_emtpy_times = 0
-                    if not self._task_model and (
-                            not wait_scheduler_execute or
-                            int(time.time()) - self._app_time > self._before_scheduler_wait_seconds
-                    ):
-                        logger.info("Done! ready to close thread...")
-                        self._stop.set()
-
-                    elif self._db.zcount(self._todo_key, _min=0, _max="(1000"):
-                        logger.info(f"Recovery {self.task} task run！")
-                        self._pause.clear()
-                        self._execute()
-                    else:
-                        logger.info("pause! waiting for resume...")
-                elif check_emtpy_times > 2:
-                    self.__DOING__ = {}
-                    if not self._db.zcount(self._todo_key, _min="-inf", _max="(1000"):
-                        self._pause.set()
-                else:
-                    logger.info(
-                        "check whether the task is complete, "
-                        f"reset times {3 - check_emtpy_times}"
-                    )
-                    check_emtpy_times += 1
-            else:
-                logger.info(LogTemplate.launcher_pro_polling.format(
-                    task=self.task,
-                    doing_len=len(self.__DOING__.keys()),
-                    todo_len=self.__LAUNCHER_QUEUE__['todo'].length,
-                    done_len=self.__LAUNCHER_QUEUE__['done'].length,
-                    redis_seed_count=self._db.zcount(self._todo_key, "-inf", "+inf"),
-                    redis_todo_len=self._db.zcount(self._todo_key, 0, "(1000"),
-                    redis_doing_len=self._db.zcount(self._todo_key, "-inf", "(0"),
-                    upload_len=self.__LAUNCHER_QUEUE__['upload'].length,
-                ))
-
-            time.sleep(pooling_wait_seconds)
-
-        logger.info("Done! Ready to close thread...")
-

cobweb/launchers/launcher_pro.py

@@ -1,222 +0,0 @@
-import time
-import threading
-
-from cobweb.db import RedisDB
-from cobweb.base import Seed, logger
-from cobweb.utils import BloomFilter
-from cobweb.constant import DealModel, LogTemplate
-from .launcher import Launcher, check_pause
-
-
-class LauncherPro(Launcher):
-
-    def __init__(self, task, project, custom_setting=None, **kwargs):
-        super().__init__(task, project, custom_setting, **kwargs)
-        self._todo_key = "{%s:%s}:todo" % (project, task)
-        self._done_key = "{%s:%s}:done" % (project, task)
-        self._fail_key = "{%s:%s}:fail" % (project, task)
-        self._heartbeat_key = "heartbeat:%s_%s" % (project, task)
-
-        self._statistics_done_key = "statistics:%s:%s:done" % (project, task)
-        self._statistics_fail_key = "statistics:%s:%s:fail" % (project, task)
-        self._speed_control_key = "speed_control:%s_%s" % (project, task)
-
-        self._reset_lock_key = "lock:reset:%s_%s" % (project, task)
-
-        self._bf_key = "bloom_%s_%s" % (project, task)
-
-        self._db = RedisDB()
-
-        self._bf = BloomFilter(self._bf_key)
-
-        self._heartbeat_start_event = threading.Event()
-        self._redis_queue_empty_event = threading.Event()
-
-    @property
-    def heartbeat(self):
-        return self._db.exists(self._heartbeat_key)
-
-    def statistics(self, key, count):
-        if not self._task_model and not self._db.exists(key):
-            self._db.setex(key, 86400 * 30, int(count))
-        else:
-            self._db._client.incrby(key, count)
-
-    def _get_seed(self) -> Seed:
-        spider_speed = self._db._client.get(self._speed_control_key)
-        if int(spider_speed or 0) > self._spider_max_count:
-            expire_time = self._db.ttl(self._speed_control_key)
-            if expire_time == -1:
-                self._db.delete(self._speed_control_key)
-            else:
-                logger.info(f"Too fast! Please wait {expire_time} seconds...")
-                time.sleep(expire_time / 2)
-            return None
-        seed = self.__LAUNCHER_QUEUE__["todo"].pop()
-        if seed and not self._db.lock(self._speed_control_key, t=self._time_window):
-            self._db._client.incrby(self._speed_control_key, 1)
-        return seed
-
-    @check_pause
-    def _execute_heartbeat(self):
-        if self._heartbeat_start_event.is_set():
-            self._db.setex(self._heartbeat_key, 5)
-        time.sleep(3)
-
-    @check_pause
-    def _reset(self):
-        """
-        检查过期种子，重新添加到redis缓存中
-        """
-        reset_wait_seconds = 30
-        if self._db.lock(self._reset_lock_key, t=120):
-
-            _min = -int(time.time()) + self._seed_reset_seconds \
-                if self.heartbeat else "-inf"
-
-            self._db.members(self._todo_key, 0, _min=_min, _max="(0")
-            self._db.delete(self._reset_lock_key)
-
-            if not self.heartbeat:
-                self._heartbeat_start_event.set()
-
-        time.sleep(reset_wait_seconds)
-
-    @check_pause
-    def _scheduler(self):
-        """
-        调度任务，获取redis队列种子，同时添加到doing字典中
-        """
-        if not self._db.zcount(self._todo_key, 0, "(1000"):
-            time.sleep(self._scheduler_wait_seconds)
-        elif self.__LAUNCHER_QUEUE__['todo'].length >= self._todo_queue_size:
-            time.sleep(self._todo_queue_full_wait_seconds)
-        else:
-            members = self._db.members(
-                self._todo_key, int(time.time()),
-                count=self._todo_queue_size,
-                _min=0, _max="(1000"
-            )
-            for member, priority in members:
-                seed = Seed(member, priority=priority)
-                self.__LAUNCHER_QUEUE__['todo'].push(seed)
-                self.__DOING__[seed.to_string] = seed.params.priority
-
-    @check_pause
-    def _insert(self):
-        """
-        添加新种子到redis队列中
-        """
-        seeds = {}
-        status = self.__LAUNCHER_QUEUE__['new'].length < self._new_queue_max_size
-        for _ in range(self._new_queue_max_size):
-            seed = self.__LAUNCHER_QUEUE__['new'].pop()
-            if seed:
-                seeds[seed.to_string] = seed.params.priority
-        if seeds:
-            self._db.zadd(self._todo_key, seeds, nx=True)
-        if status:
-            time.sleep(self._new_queue_wait_seconds)
-
-    @check_pause
-    def _refresh(self):
-        """
-        刷新doing种子过期时间，防止reset重新消费
-        """
-        if self.__DOING__:
-            refresh_time = int(time.time())
-            seeds = {k:-refresh_time - v / 1000 for k, v in self.__DOING__.items()}
-            self._db.zadd(self._todo_key, item=seeds, xx=True)
-        time.sleep(15)
-
-    @check_pause
-    def _delete(self):
-        """
-        删除队列种子，根据状态添加至成功或失败队列，移除doing字典种子索引
-        """
-        seed_info = {"count": 0, "failed": [], "succeed": [], "common": []}
-        status = self.__LAUNCHER_QUEUE__['done'].length < self._done_queue_max_size
-
-        for _ in range(self._done_queue_max_size):
-            seed = self.__LAUNCHER_QUEUE__['done'].pop()
-            if not seed:
-                break
-            if seed.params.seed_status == DealModel.fail:
-                seed_info["failed"].append(seed.to_string)
-            elif self._done_model == 1:
-                seed_info["succeed"].append(seed.to_string)
-            else:
-                seed_info["common"].append(seed.to_string)
-            seed_info['count'] += 1
-
-        if seed_info["count"]:
-
-            succeed_count = int(self._db.zrem(self._todo_key, *seed_info["common"]) or 0)
-            succeed_count += int(self._db.done([self._todo_key, self._done_key], *seed_info["succeed"]) or 0)
-            failed_count = int(self._db.done([self._todo_key, self._fail_key], *seed_info["failed"]) or 0)
-
-            if failed_count:
-                self.statistics(self._statistics_fail_key, failed_count)
-            if succeed_count:
-                self.statistics(self._statistics_done_key, succeed_count)
-
-            self._remove_doing_seeds(seed_info["common"] + seed_info["succeed"] + seed_info["failed"])
-
-        if status:
-            time.sleep(self._done_queue_wait_seconds)
-
-    def _polling(self):
-        wait_scheduler_execute = True
-        check_emtpy_times = 0
-        while not self._stop.is_set():
-            queue_not_empty_count = 0
-            pooling_wait_seconds = 30
-
-            for q in self.__LAUNCHER_QUEUE__.values():
-                if q.length != 0:
-                    queue_not_empty_count += 1
-                    wait_scheduler_execute = False
-
-            if queue_not_empty_count == 0:
-                pooling_wait_seconds = 3
-                if self._pause.is_set():
-                    check_emtpy_times = 0
-                    if not self._task_model and (
-                            not wait_scheduler_execute or
-                            int(time.time()) - self._app_time > self._before_scheduler_wait_seconds
-                    ):
-                        logger.info("Done! ready to close thread...")
-                        self._stop.set()
-
-                    elif self._db.zcount(self._todo_key, _min=0, _max="(1000"):
-                        logger.info(f"Recovery {self.task} task run！")
-                        self._pause.clear()
-                        self._execute()
-                    else:
-                        logger.info("pause! waiting for resume...")
-                elif check_emtpy_times > 2:
-                    self.__DOING__ = {}
-                    if not self._db.zcount(self._todo_key, _min="-inf", _max="(1000"):
-                        self._pause.set()
-                else:
-                    logger.info(
-                        "check whether the task is complete, "
-                        f"reset times {3 - check_emtpy_times}"
-                    )
-                    check_emtpy_times += 1
-            else:
-                logger.info(LogTemplate.launcher_pro_polling.format(
-                    task=self.task,
-                    doing_len=len(self.__DOING__.keys()),
-                    todo_len=self.__LAUNCHER_QUEUE__['todo'].length,
-                    done_len=self.__LAUNCHER_QUEUE__['done'].length,
-                    redis_seed_count=self._db.zcount(self._todo_key, "-inf", "+inf"),
-                    redis_todo_len=self._db.zcount(self._todo_key, 0, "(1000"),
-                    redis_doing_len=self._db.zcount(self._todo_key, "-inf", "(0"),
-                    upload_len=self.__LAUNCHER_QUEUE__['upload'].length,
-                ))
-
-            time.sleep(pooling_wait_seconds)
-
-        logger.info("Done! Ready to close thread...")
-

cobweb/pipelines/base_pipeline.py

@@ -1,54 +0,0 @@
-import time
-import threading
-
-from abc import ABC, abstractmethod
-from cobweb.base import BaseItem, Queue, logger
-
-
-class Pipeline(threading.Thread, ABC):
-
-    def __init__(
-            self,
-            done_queue: Queue,
-            upload_queue: Queue,
-            upload_queue_size: int,
-            upload_wait_seconds: int
-    ):
-        super().__init__()
-        self.done_queue = done_queue
-        self.upload_queue = upload_queue
-        self.upload_queue_size = upload_queue_size
-        self.upload_wait_seconds = upload_wait_seconds
-
-    @abstractmethod
-    def build(self, item: BaseItem) -> dict:
-        pass
-
-    @abstractmethod
-    def upload(self, table: str, data: list) -> bool:
-        pass
-
-    def run(self):
-        while True:
-            status = self.upload_queue.length < self.upload_queue_size
-            if status:
-                time.sleep(self.upload_wait_seconds)
-            data_info, seeds = {}, []
-            for _ in range(self.upload_queue_size):
-                item = self.upload_queue.pop()
-                if not item:
-                    break
-                data = self.build(item)
-                seeds.append(item.seed)
-                data_info.setdefault(item.table, []).append(data)
-            for table, datas in data_info.items():
-                try:
-                    self.upload(table, datas)
-                    status = True
-                except Exception as e:
-                    logger.info(e)
-                    status = False
-                if status:
-                    self.done_queue.push(seeds)
-
-

cobweb/pipelines/loghub_pipeline.py

@@ -1,34 +0,0 @@
-import json
-
-from cobweb import setting
-from cobweb.base import BaseItem
-from cobweb.pipelines import Pipeline
-from aliyun.log import LogClient, LogItem, PutLogsRequest
-
-
-class LoghubPipeline(Pipeline):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.client = LogClient(**setting.LOGHUB_CONFIG)
-
-    def build(self, item: BaseItem):
-        log_item = LogItem()
-        temp = item.to_dict
-        for key, value in temp.items():
-            if not isinstance(value, str):
-                temp[key] = json.dumps(value, ensure_ascii=False)
-        contents = sorted(temp.items())
-        log_item.set_contents(contents)
-        return log_item
-
-    def upload(self, table, datas):
-        request = PutLogsRequest(
-            project=setting.LOGHUB_PROJECT,
-            logstore=table,
-            topic=setting.LOGHUB_TOPIC,
-            source=setting.LOGHUB_SOURCE,
-            logitems=datas,
-            compress=True
-        )
-        self.client.put_logs(request=request)

cobweb/pipelines/pipeline_console.py

@@ -1,22 +0,0 @@
-from cobweb.base import ConsoleItem, logger
-from cobweb.constant import LogTemplate
-from cobweb.pipelines import Pipeline
-
-
-class Console(Pipeline):
-
-    def build(self, item: ConsoleItem):
-        return {
-            "seed": item.seed.to_dict,
-            "data": item.to_dict
-        }
-
-    def upload(self, table, datas):
-        for data in datas:
-            parse_detail = LogTemplate.log_info(data["data"])
-            if len(parse_detail) > 500:
-                parse_detail = parse_detail[:500] + " ...\n" + " " * 12 + "-- Text is too long and details are omitted!"
-            logger.info(LogTemplate.console_item.format(
-                seed_detail=LogTemplate.log_info(data["seed"]),
-                parse_detail=parse_detail
-            ))

cobweb_launcher-1.2.25.dist-info/RECORD

@@ -1,40 +0,0 @@
-cobweb/__init__.py,sha256=CBd2oByCfc5EmH2dCZYVHkxXYZG-oWrLyTtZU5sEoP0,96
-cobweb/constant.py,sha256=zy3XYsc1qp2B76_Fn_hVQ8eGHlPBd3OFlZK2cryE6FY,2839
-cobweb/setting.py,sha256=47HZsw40HLpsmOmvij1lyQALPQQCN_tWlKZ0wbn2MtM,2216
-cobweb/base/__init__.py,sha256=4gwWWQ0Q8cYG9cD7Lwf4XMqRGc5M_mapS3IczR6zeCE,222
-cobweb/base/common_queue.py,sha256=W7PPZZFl52j3Mc916T0imHj7oAUelA6aKJwW-FecDPE,872
-cobweb/base/decorators.py,sha256=wDCaQ94aAZGxks9Ljc0aXq6omDXT1_yzFy83ZW6VbVI,930
-cobweb/base/item.py,sha256=hYheVTV2Bozp4iciJpE2ZwBIXkaqBg4QQkRccP8yoVk,1049
-cobweb/base/log.py,sha256=L01hXdk3L2qEm9X1FOXQ9VmWIoHSELe0cyZvrdAN61A,2003
-cobweb/base/request.py,sha256=tEkgMVUfdQI-kZuzWuiit9P_q4Q9-_RZh9aXXpc0314,2352
-cobweb/base/response.py,sha256=eB1DWMXFCpn3cJ3yzgCRU1WeZAdayGDohRgdjdMUFN4,406
-cobweb/base/seed.py,sha256=Uz_VBRlAxNYQcFHk3tsZFMlU96yPOedHaWGTvk-zKd8,2908
-cobweb/crawlers/__init__.py,sha256=msvkB9mTpsgyj8JfNMsmwAcpy5kWk_2NrO1Adw2Hkw0,29
-cobweb/crawlers/base_crawler.py,sha256=ee_WSDnPQpPTk6wlFuY2UEx5L3hcsAZFcr6i3GLSry8,5751
-cobweb/crawlers/crawler.py,sha256=xiFNM0t69f5xlm59hPbO2MpqtdirVAUhD84-CLpyHPM,6349
-cobweb/crawlers/file_crawler.py,sha256=2Sjbdgxzqd41WykKUQE3QQlGai3T8k-pmHNmPlTchjQ,4454
-cobweb/db/__init__.py,sha256=uZwSkd105EAwYo95oZQXAfofUKHVIAZZIPpNMy-hm2Q,56
-cobweb/db/api_db.py,sha256=bDc5dJQxq4z04h70KUTHd0OqUOEY7Cm3wcNJZtTvJIM,3015
-cobweb/db/redis_db.py,sha256=fumNZJiio-uQqRcSrymx8eJ1PqsdOwITe_Y-9JOXxrQ,4298
-cobweb/exceptions/__init__.py,sha256=E9SHnJBbhD7fOgPFMswqyOf8SKRDrI_i25L0bSpohvk,32
-cobweb/exceptions/oss_db_exception.py,sha256=iP_AImjNHT3-Iv49zCFQ3rdLnlvuHa3h2BXApgrOYpA,636
-cobweb/launchers/__init__.py,sha256=qMuVlQcjErVK67HyKFZEsXf_rfZD5ODjx1QucSCKMOM,114
-cobweb/launchers/launcher.py,sha256=SK4f3Fpuv-QMMriHruXGQ1sh1lxT1DZ2PdG0p2wAzNw,6978
-cobweb/launchers/launcher_air.py,sha256=KAk_M8F3029cXYe7m4nn3Nzyi89lbxJ2cqZjqW8iZ0E,2832
-cobweb/launchers/launcher_api.py,sha256=Ih8f5xDcFlGBn6VSnlrpxcchMB48ugsj2NTWYgGYWfY,8669
-cobweb/launchers/launcher_pro.py,sha256=NBJstQuB0o_jMiySJ14lk0Y3WAxxiScaQvXa1qtTSo4,8683
-cobweb/pipelines/__init__.py,sha256=zSUsGtx6smbs2iXBXvYynReKSgky-3gjqaAtKVnA_OU,105
-cobweb/pipelines/base_pipeline.py,sha256=fYnWf79GmhufXpcnMa3te18SbmnVeYLwxfyo-zLd9CY,1577
-cobweb/pipelines/loghub_pipeline.py,sha256=cjPO6w6UJ0jNw2fVvdX0BCdlm58T7dmYXlxzXOBpvfY,1027
-cobweb/pipelines/pipeline.py,sha256=4TJLX0sUHRxYndF5A4Vs5btUGI-wigkOcFvhTW1hLXI,2009
-cobweb/pipelines/pipeline_console.py,sha256=NEh-4zhuVAQOqwXLsqeb-rcNZ9_KXFUpL3otUTL5qBs,754
-cobweb/pipelines/pipeline_loghub.py,sha256=xZ6D55BGdiM71WUv83jyLGbEyUwhBHLJRZoXthBxxTs,1019
-cobweb/utils/__init__.py,sha256=vBtZTy3EfRE0MmH43URhmr7nw6_oOWTEbGOM9xR_9o8,78
-cobweb/utils/bloom.py,sha256=vng-YbKgh9HbtpAWYf_nkUSbfVTOj40aqUUejRYlsCU,1752
-cobweb/utils/oss.py,sha256=gyt8-UB07tVphZLQXMOf-JTJwU-mWq8KZkOXKkAf3uk,3513
-cobweb/utils/tools.py,sha256=5JEaaAwYoV9Sdla2UBIJn6faUBuXmxUMagm9ck6FVqs,1253
-cobweb_launcher-1.2.25.dist-info/LICENSE,sha256=z1rxSIGOyzcSb3orZxFPxzx-0C1vTocmswqBNxpKfEk,1063
-cobweb_launcher-1.2.25.dist-info/METADATA,sha256=I2DC0dBkKiIKUNmGWA2JNMaQhhydniKDJT3gteawVOg,6510
-cobweb_launcher-1.2.25.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
-cobweb_launcher-1.2.25.dist-info/top_level.txt,sha256=4GETBGNsKqiCUezmT-mJn7tjhcDlu7nLIV5gGgHBW4I,7
-cobweb_launcher-1.2.25.dist-info/RECORD,,