scrapy-cffi 0.1.0__tar.gz

scrapy_cffi-0.1.0/LICENSE

@@ -0,0 +1,38 @@
+Portions of this project are derived from the Scrapy project (https://github.com/scrapy/scrapy),
+which is licensed under the BSD 3-Clause License.
+
+In particular, the `item.py` module is adapted from Scrapy's `scrapy/item.py`
+with necessary adjustments for integration with the asyncio-based engine.
+Original copyright:
+Copyright (c) Scrapy developers. All rights reserved.
+
+---
+
+BSD 3-Clause License
+
+Copyright (c) 2025, aFunnyStrange
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions, and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

scrapy_cffi-0.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include scrapy_cffi/templates *
+
+global-exclude __pycache__/
+global-exclude *.py[cod]

scrapy_cffi-0.1.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: scrapy_cffi
+Version: 0.1.0
+Summary: An asyncio-style web scraping framework inspired by Scrapy, powered by curl_cffi.
+Author: aFunnyStrange
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/aFunnyStrange/scrapy_cffi
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: curl_cffi
+Requires-Dist: PyExecjs
+Requires-Dist: orjson
+Requires-Dist: json5
+Requires-Dist: bbpb
+Requires-Dist: toml
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: jinja2
+Requires-Dist: tenacity
+Requires-Dist: redis>=5.0.0
+Requires-Dist: parsel
+Requires-Dist: Pillow
+Requires-Dist: hachoir
+Provides-Extra: windows
+Requires-Dist: python-magic-bin; extra == "windows"
+Provides-Extra: unix
+Requires-Dist: python-magic; extra == "unix"
+Dynamic: license-file
+
+## scrapy_cffi
+
+> An asyncio-style web scraping framework inspired by Scrapy, powered by `curl_cffi`.
+
+`scrapy_cffi` is a lightweight asynchronous crawling framework that mimics the Scrapy architecture while replacing Twisted with `curl_cffi` as the underlying HTTP/WebSocket client. It is designed to be efficient, extensible, and suitable for both simple tasks and complex distributed crawlers.
+
+---
+
+## ✨ Features
+
+- Familiar Scrapy-style components: spiders, items, interceptors, pipelines
+- Fully asyncio-based engine
+- Built-in support for HTTP and WebSocket requests
+- Lightweight signal system
+- Plug-in ready interceptor and task manager design
+- Redis-compatible scheduler (optional)
+- Designed for high-concurrency crawling
+
+---
+
+## 📦 Installation
+#### From PyPI
+
+```bash
+pip install scrapy_cffi
+```
+
+#### From source
+```bash
+git clone https://github.com/aFunnyStrange/scrapy_cffi.git
+cd curl_cffi
+pip install -e .
+```
+
+## 🚀 Quick Start
+```bash
+scrapy_cffi startproject <project_name>
+cd <project_name>
+scrapy_cffi genspider <spider_name> <domain>
+python runner.py
+```
+
+## 📖 Documentation
+Technical module-level documentation can be found in the [`docs/`](https://github.com/aFunnyStrange/scrapy_cffi/tree/main/docs/usage) directory on GitHub.
+Each core component (engine, downloader, middleware, etc.) has its own `.md` file.
+
+## 📄 License
+This project is licensed under the BSD 3-Clause License. Portions of the code (specifically item.py) are adapted from the Scrapy project.
+See LICENSE for details.

scrapy_cffi-0.1.0/README.md

@@ -0,0 +1,49 @@
+## scrapy_cffi
+
+> An asyncio-style web scraping framework inspired by Scrapy, powered by `curl_cffi`.
+
+`scrapy_cffi` is a lightweight asynchronous crawling framework that mimics the Scrapy architecture while replacing Twisted with `curl_cffi` as the underlying HTTP/WebSocket client. It is designed to be efficient, extensible, and suitable for both simple tasks and complex distributed crawlers.
+
+---
+
+## ✨ Features
+
+- Familiar Scrapy-style components: spiders, items, interceptors, pipelines
+- Fully asyncio-based engine
+- Built-in support for HTTP and WebSocket requests
+- Lightweight signal system
+- Plug-in ready interceptor and task manager design
+- Redis-compatible scheduler (optional)
+- Designed for high-concurrency crawling
+
+---
+
+## 📦 Installation
+#### From PyPI
+
+```bash
+pip install scrapy_cffi
+```
+
+#### From source
+```bash
+git clone https://github.com/aFunnyStrange/scrapy_cffi.git
+cd curl_cffi
+pip install -e .
+```
+
+## 🚀 Quick Start
+```bash
+scrapy_cffi startproject <project_name>
+cd <project_name>
+scrapy_cffi genspider <spider_name> <domain>
+python runner.py
+```
+
+## 📖 Documentation
+Technical module-level documentation can be found in the [`docs/`](https://github.com/aFunnyStrange/scrapy_cffi/tree/main/docs/usage) directory on GitHub.
+Each core component (engine, downloader, middleware, etc.) has its own `.md` file.
+
+## 📄 License
+This project is licensed under the BSD 3-Clause License. Portions of the code (specifically item.py) are adapted from the Scrapy project.
+See LICENSE for details.

scrapy_cffi-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scrapy_cffi"
+version = "0.1.0"
+description = "An asyncio-style web scraping framework inspired by Scrapy, powered by curl_cffi."
+authors = [{name = "aFunnyStrange"}]
+license = {text = "BSD-3-Clause"}
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "curl_cffi",
+    "PyExecjs",
+    "orjson",
+    "json5",
+    "bbpb",
+    "toml",
+    "pydantic>=2.0.0",
+    "jinja2",
+    "tenacity",
+    "redis>=5.0.0",
+    "parsel",
+    "Pillow",
+    "hachoir",
+]
+[project.optional-dependencies]
+windows = ["python-magic-bin"]
+unix = ["python-magic"]
+
+[project.urls]
+Homepage = "https://github.com/aFunnyStrange/scrapy_cffi"
+
+[tool.setuptools.packages.find]
+include = ["scrapy_cffi", "scrapy_cffi.*"]
+exclude = ["docs*", "tests*", "examples*"]
+
+[project.scripts]
+scrapy_cffi = "scrapy_cffi.commands.main:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+"scrapy_cffi" = ["templates/*"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["__pycache__/*", "*.py[cod]"]

scrapy_cffi-0.1.0/scrapy_cffi/__init__.py

@@ -0,0 +1,13 @@
+__version__ = "0.1.0"
+
+from .crawler import run_spider, run_all_spiders, run_spider_sync, run_all_spiders_sync, cleanup_loop
+from .utils import load_settings_with_path, init_logger, run_coroutine_in_thread, run_coroutine_in_new_loop, ProcessTaskManager
+
+__all__ = [
+    "run_spider",
+    "run_all_spiders",
+    "run_spider_sync",
+    "run_all_spiders_sync",
+    "load_settings_with_path",
+    "init_logger"
+]

scrapy_cffi-0.1.0/scrapy_cffi/commands/base.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+
+def find_project_root(start: Path = None, is_demo=False) -> Path:
+    if start is None:
+        start = Path.cwd()
+    all_path = [start / "demo"] if is_demo else [start, *start.parents]
+    for path in all_path:
+        if (path / "scrapy_cffi.toml").exists():
+            return path
+    raise FileNotFoundError("Project root not found (missing scrapy_cffi.toml)")

scrapy_cffi-0.1.0/scrapy_cffi/commands/demo.py

@@ -0,0 +1,112 @@
+import shutil, os
+from pathlib import Path
+from typing import List
+
+def copytree_merge(src: Path, dst: Path):
+    src = Path(src)
+    dst = Path(dst)
+    if not src.is_dir():
+        raise ValueError(f"not dir: {src}")
+
+    if not dst.exists():
+        os.makedirs(dst)
+
+    for item in src.iterdir():
+        s = src / item.name
+        d = dst / item.name
+        if s.is_dir():
+            copytree_merge(s, d)
+        else:
+            shutil.copy2(s, d)
+
+def run(use_task: bool, use_redis: bool):
+    base = Path(__file__).parent.parent # scrapy_cffi
+    template_dir = base / "templates"
+    target: Path = Path.cwd() / "demo"
+
+    settings_path = target / "spiders" / "settings.py" if use_task else target / "settings.py"
+    settings_code = settings_path.read_text(encoding='utf-8')
+    settings_code = settings_code.replace('# settings.EXTENSIONS_PATH', 'settings.EXTENSIONS_PATH')
+    settings_code = settings_code.replace('# settings.ITEM_PIPELINES_PATH', 'settings.ITEM_PIPELINES_PATH')
+    settings_code = settings_code.replace('# "interceptors.CustomDownloadInterceptor1"', '"interceptors.CustomDownloadInterceptor1"')
+    settings_code = settings_code.replace('# "interceptors.CustomDownloadInterceptor2"', '"interceptors.CustomDownloadInterceptor2"')
+    settings_path.write_text(settings_code, encoding='utf-8')
+
+    spider_dir = target / "spiders" / "spiders" if use_task else target / "spiders"
+    demo_spiders_dir = template_dir / "demo_spider"
+    
+    # demo_server
+    copytree_merge(template_dir / "server", target)
+    readme_path = target / "readme.txt"
+    readme_code = readme_path.read_text(encoding='utf-8')
+    if use_task:
+        readme_code = readme_code.replace('2.run runner.py', '2.run manager.py')
+    if use_redis:
+        readme_code = readme_code + '\n3.redis-cli\n4.RPUSH customRedisSpider_test http://127.0.0.1:8002\r\n'
+    readme_path.write_text(readme_code, encoding='utf-8')
+
+    if use_redis:
+        from .base import find_project_root
+        from .genspider import check_use_redis
+        project_path = find_project_root(is_demo=True)
+        use_task = check_use_redis(project_path, use_redis, use_task)
+
+        demo_spider_files = ["customRedisSpider", "studentSpider"]
+        for demo_spider in demo_spider_files:
+            demo_spider_path = demo_spiders_dir / f'{demo_spider}.py'
+            target_spider_path = spider_dir / f'{demo_spider}.py'
+            demo_spider_code = demo_spider_path.read_text(encoding='utf-8')
+            target_spider_path.parent.mkdir(parents=True, exist_ok=True)
+            target_spider_path.write_text(demo_spider_code, encoding='utf-8')
+
+        update_spiders_path(
+            project_path=target, 
+            demo_spiders_dir=demo_spiders_dir, 
+            demo_spider_files=demo_spider_files, 
+            spider_dir=spider_dir, 
+            use_task=use_task, 
+            use_redis=use_redis
+        )
+        # runner.py update spider_path
+
+        # module path with `spiders`
+        spiders_dir = target / "spiders" if use_task else target
+        runner_path = spiders_dir / "runner.py"
+        runner_code = runner_path.read_text(encoding='utf-8')
+        runner_code = runner_code.replace('crawler, engine_task = await advance_main()', '# crawler, engine_task = await advance_main()')
+        runner_code = runner_code.replace('# crawler, engine_task = await advance_main_all()', 'crawler, engine_task = await advance_main_all()')
+        runner_code = runner_code.replace('import threading', '# import threading')
+        runner_code = runner_code.replace('t = threading.Thread(', '# t = threading.Thread(')
+        runner_code = runner_code.replace('t.start()', '# t.start()')
+        runner_code = runner_code.replace('t.join()', '# t.join()')
+        runner_code = runner_code.replace(' main()', ' # main()')
+        if use_task:
+            runner_code = runner_code.replace('spider_path="spiders.CustomSpider"', 'spider_path="spiders.spiders.CustomRedisSpider"')
+            runner_code = runner_code.replace('get_run_py_dir() / "spiders"', 'get_run_py_dir() / "spiders" / "spiders"')
+        runner_path.write_text(runner_code, encoding='utf-8')
+    else:
+        spider_dir.mkdir(parents=True, exist_ok=True)
+        demo_spider_files = ["customSpider", "studentSpider"]
+        for demo_spider in demo_spider_files:
+            demo_spider_path = demo_spiders_dir / f'{demo_spider}.py'
+            target_spider_path = spider_dir / f'{demo_spider}.py'
+            demo_spider_code = demo_spider_path.read_text(encoding='utf-8')
+            target_spider_path.parent.mkdir(parents=True, exist_ok=True)
+            target_spider_path.write_text(demo_spider_code, encoding='utf-8')
+        update_spiders_path(project_path=target, demo_spiders_dir=demo_spiders_dir, demo_spider_files=demo_spider_files, spider_dir=spider_dir, use_task=use_task, use_redis=use_redis)
+
+    print(f"Project 'demo' with tasks manager created.") if use_task else print(f"Project 'demo' created.")
+
+def update_spiders_path(project_path: Path, demo_spiders_dir: Path, demo_spider_files: List, spider_dir: Path, use_task: bool, use_redis: bool):
+    for spider_name in demo_spider_files:
+        spider_path = demo_spiders_dir / f"{spider_name}.py"
+        spider_code = spider_path.read_text('utf-8')
+
+        write_path = spider_dir / f"{spider_name}.py"
+        if use_task:
+            spider_code = spider_code.replace("from items.item import CustomItem", "from spiders.items.item import CustomItem")
+        write_path.write_text(spider_code, encoding='utf-8')
+        cls_name = spider_name[0].upper() + spider_name[1:] if spider_name else spider_name
+        # update __init__.py
+        from .genspider import update_spiders_init
+        update_spiders_init(project_path=project_path, class_name=cls_name, spider_name=spider_name, use_task=use_task)

scrapy_cffi-0.1.0/scrapy_cffi/commands/genspider.py

@@ -0,0 +1,83 @@
+import toml
+from ..utils import load_settings_from_py
+from pathlib import Path
+from jinja2 import Template
+
+def check_use_redis(project_path: Path, use_redis: bool=False, use_task: bool=False):
+    config_path = project_path / "scrapy_cffi.toml"
+
+    config_data = toml.load(config_path)
+    if config_data.get("default"):
+        if not use_task:
+            use_task = config_data["default"].get("use_task", False)
+        if use_redis and (not config_data["default"].get("use_redis", False)):
+            config_data["default"]["use_redis"] = True
+            with config_path.open("w", encoding="utf-8") as f:
+                toml.dump(config_data, f)
+
+            # Scheduler -> RedisScheduler
+            settings_file = project_path / "spiders" / "settings.py" if use_task else project_path / "settings.py"
+            settings_data = settings_file.read_text(encoding='utf-8')
+            if 'def create_settings(spider_path, user_redis=False, *args, **kwargs):' in settings_data:
+                settings_data = settings_data.replace('def create_settings(spider_path, user_redis=False, *args, **kwargs):', 'def create_settings(spider_path, user_redis=True, *args, **kwargs):')
+                settings_file.write_text(settings_data, encoding="utf-8")
+            # update config.py
+            if use_task:
+                task_config_path = project_path / "config.py"
+                if task_config_path.exists():
+                    task_config = load_settings_from_py(task_config_path, auto_upper=False)
+                    if not task_config.get("redis_url"):
+                        with task_config_path.open("a", encoding="utf-8") as f:
+                            f.write('\nredis_url = "redis://127.0.0.1:6379"\n')
+    return use_task
+
+def run(spider_name: str, allow_domain: str, use_redis: bool, is_demo=False):
+    from .base import find_project_root
+    project_path = find_project_root()
+    use_task = check_use_redis(project_path, use_redis)
+
+    class_name = snake_to_camel(spider_name)
+    base_class = "RedisSpider" if use_redis else "Spider"
+    base_import = "scrapy_cffi.spiders"
+    start_urls = f'redis_key = ""' if use_redis else f'start_urls = ["https://{allow_domain}"]'
+
+    base = Path(__file__).parent.parent # scrapy_cffi
+    template_dir = base / "templates"
+    with open(template_dir / "spider.py.j2", "r", encoding="utf-8") as f:
+        template: Template = Template(f.read())
+    
+    code = template.render(
+        class_name=class_name,
+        spider_name=spider_name,
+        domain=allow_domain,
+        base_class=base_class,
+        base_import=base_import,
+        start_urls=start_urls
+    )
+    target_file = project_path / "spiders" / "spiders" / f"{spider_name}.py" if use_task else project_path / "spiders" / f"{spider_name}.py" # use abspath
+    target_file.parent.mkdir(parents=True, exist_ok=True)
+    target_file.write_text(code, encoding="utf-8")
+
+    # To avoid overwriting user-defined content, only spider templates should be regenerated; other files should be appended or updated dynamically.
+    update_spiders_init(project_path, class_name, spider_name, use_task)
+    if not is_demo:
+        print(f"Spider created: {target_file}")
+
+# Use this to automatically convert snake_case to camelCase.
+def snake_to_camel(name: str) -> str:
+    return ''.join(word.capitalize() for word in name.split('_')) + "Spider"
+
+# auto import
+def update_spiders_init(project_path: Path, class_name: str, spider_name: str, use_task: bool):
+    init_path =project_path / "spiders" / "spiders" / "__init__.py" if use_task else project_path / "spiders" / "__init__.py"
+    import_line = f"from .{spider_name} import {class_name}\n"
+
+    if not init_path.exists():
+        init_path.write_text(import_line, encoding="utf-8")
+        return
+
+    init_data = init_path.read_text(encoding='utf-8')
+    if import_line in init_data:
+        return
+    with open(init_path, "a", encoding="utf-8") as f:
+        f.write(import_line)

scrapy_cffi-0.1.0/scrapy_cffi/commands/main.py

@@ -0,0 +1,43 @@
+import argparse
+from . import startproject, genspider, demo
+
+def main():
+    parser = argparse.ArgumentParser(prog="scrapy_cffi", description="scrapy_cffi CLI tool")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # startproject
+    sp = subparsers.add_parser("startproject", help="Create a new project")
+    sp.add_argument("name", help="Project name")
+    sp.add_argument("-t", "--task", action="store_true", help="Create a new project with tasks manager")
+
+    # genspider
+    gp = subparsers.add_parser("genspider", help="Generate a new spider")
+    gp.add_argument("-r", "--redis", action="store_true", help="Use RedisSpider")
+    gp.add_argument("name", help="Spider name")
+    gp.add_argument("domain", help="Target domain")
+
+    # demo project
+    demo_p = subparsers.add_parser("demo", help="Create a demo project")
+    demo_p.add_argument("-t", "--task", action="store_true", help="with tasks manager")
+    demo_p.add_argument("-r", "--redis", action="store_true", help="Use RedisSpider")
+
+    # export
+    # ep = subparsers.add_parser("export", help="Export files")
+    # ep.add_argument("name", help="Filename")
+
+    args = parser.parse_args()
+
+    if args.command == "startproject":
+        startproject.run(args.name, args.task)
+    elif args.command == "genspider":
+        genspider.run(args.name, args.domain, args.redis)
+    # elif args.command == "export":
+    #     export.run(args.name)
+    elif args.command == "demo":
+        result = startproject.run("demo", args.task, is_demo=True)
+        if result is not None:
+            return
+        demo.run(args.task, args.redis)
+    else:
+        print(f"Unknown command: {args.command}")
+        parser.print_help()

scrapy_cffi-0.1.0/scrapy_cffi/commands/startproject.py

@@ -0,0 +1,47 @@
+import shutil, toml
+from pathlib import Path
+
+def run(project_name, use_task: bool, is_demo=False):
+    base = Path(__file__).parent.parent # scrapy_cffi
+    template_dir = base / "templates"
+    target: Path = Path.cwd() / project_name
+
+    if target.exists():
+        print(f"Error: Project '{project_name}' already exists.")
+        return False
+    
+    if use_task:
+        shutil.copytree(template_dir / "task", target)
+    spiders_dir = target / "spiders" if use_task else target
+    shutil.copytree(template_dir / "spiders", spiders_dir)
+    shutil.copytree(template_dir / "js_path", target / "js_path")
+    
+    if use_task:
+        # module path with `spiders`
+        runner_path = spiders_dir / "runner.py"
+        runner_code = runner_path.read_text(encoding='utf-8')
+        runner_code = runner_code.replace('from settings import create_settings', 'from spiders.settings import create_settings')
+        runner_path.write_text(runner_code, encoding='utf-8')
+
+        settings_path = spiders_dir / "settings.py"
+        settings_code = settings_path.read_text(encoding='utf-8')
+        settings_code = settings_code.replace('"extensions.CustomExtension"', '"spiders.extensions.CustomExtension"')
+        settings_code = settings_code.replace('"pipelines.CustomPipeline2"', '"spiders.pipelines.CustomPipeline2"')
+        settings_code = settings_code.replace('"pipelines.CustomPipeline1"', '"spiders.pipelines.CustomPipeline1"')
+        settings_code = settings_code.replace('"interceptors.CustomDownloadInterceptor1"', '"spiders.interceptors.CustomDownloadInterceptor1"')
+        settings_code = settings_code.replace('"interceptors.CustomDownloadInterceptor2"', '"spiders.interceptors.CustomDownloadInterceptor2"')
+        settings_path.write_text(settings_code, encoding='utf-8')
+
+    config_data = {
+        "default": {
+            "project_name": project_name,
+            "use_task": use_task
+        }
+    }
+    config_path = target / "scrapy_cffi.toml"
+    with config_path.open("w", encoding="utf-8") as f:
+        toml.dump(config_data, f)
+    if not is_demo:
+        print(f"Project '{project_name}' created.")
+        print(f"\tcd {project_name}")
+        print(f"\tscrapy_cffi genspider <spider_name> <domain>")

scrapy_cffi-0.1.0/scrapy_cffi/core/__init__.py

@@ -0,0 +1,10 @@
+from .downloader import Request, HttpRequest, WebSocketRequest, Response, HttpResponse, WebSocketResponse
+
+__all__ = [
+    "Request",
+    "HttpRequest",
+    "WebSocketRequest",
+    "Response",
+    "HttpResponse",
+    "WebSocketResponse",
+]

scrapy_cffi-0.1.0/scrapy_cffi/core/api.py

@@ -0,0 +1,11 @@
+from .sessions import SessionManager
+from .engine import Engine
+from .tasks import TaskManager
+from .downloader import Downloader
+
+__all__ = [
+    "SessionManager",
+    "Engine",
+    "TaskManager",
+    "Downloader"
+]

scrapy_cffi-0.1.0/scrapy_cffi/core/downloader/__init__.py

@@ -0,0 +1,12 @@
+from .fetch import Downloader
+from .internet import Request, HttpRequest, WebSocketRequest, Response, HttpResponse, WebSocketResponse
+
+__all__ = [
+    "Downloader",
+    "Request",
+    "HttpRequest",
+    "WebSocketRequest",
+    "Response",
+    "HttpResponse",
+    "WebSocketResponse",
+]