Move LFS

Scrape.py

@@ -0,0 +1,414 @@
+import asyncio
+import json
+import random
+import subprocess
+import httpx
+import tqdm
+import pathlib
+import backoff
+import urllib.parse
+import aiofiles
+from concurrent.futures import ThreadPoolExecutor
+from natsort import natsorted, ns
+import orjson
+from bs4 import BeautifulSoup
+import idna
+import inspect
+
+ROOT = pathlib.Path.cwd()
+GOOGLE = False
+ASYNC_CALL = 250 # No. of requests at once.
+
+def get_write_path(url, filename: pathlib.Path = None):
+    if filename is None:
+        path = urllib.parse.urlsplit(url).path
+        if path.startswith("/"):
+            path = path[1:]
+        filename = pathlib.Path(path)
+    filepath = ROOT.resolve() / filename
+    if not filepath.suffix.lower() in [".json", ".html", ".xml"]:
+        filepath = filepath.with_suffix(".html")
+    return filepath
+
+def record_response(response: httpx.Response, filename: pathlib.Path = None):
+    filepath = get_write_path(str(response.url), filename=filename)
+    parent = filepath.parent
+    reserved = ["con","prn","aux","clock","nul",
+                "com1","com2","com3","com4","com5", "com6","com7","com8","com9",
+                "lpt1","lpt2","lpt3","lpt4","lpt5", "lpt6","lpt7","lpt8","lpt9",
+                ]
+    if parent.stem in reserved:
+        # fuck
+        parent = parent.with_stem(f"!{parent.stem}")
+    parent.mkdir(parents=True, exist_ok=True)
+    (parent / filepath.name).write_text(response.text, encoding="utf-8")
+
+def agent():
+    if GOOGLE:
+        return f"Mozilla/5.0 AppleWebKit/537.36 (KHTML, like Gecko; compatible; Googlebot/2.1; +http://www.google.com/bot.html) Chrome/{random.randint(100,111)}.0.0.0 Safari/537.36"
+    return f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{random.randint(100,111)}.0.0.0 Safari/537.36"
+
+limits = httpx.Limits(max_keepalive_connections=None, max_connections=None)
+
+session = httpx.AsyncClient(limits=limits, verify=False)
+
+# Scraping.. - Shinon
+
+@backoff.on_exception(backoff.expo, httpx.HTTPError)
+@backoff.on_predicate(backoff.expo)
+async def get_url(url, record_filename=None, use_cached=True, no_read=False, noisy=0.0, record_func=record_response):
+    session.headers.update(
+        {
+            "User-Agent": agent(),
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-encoding": "gzip, deflate",
+            "accept-language": "jp",
+        }
+    )
+    if noisy:
+        await asyncio.sleep(random.uniform(0, noisy))
+    session.cookies.clear()
+    session.cookies.set("age_check","1", ".blog.fc2.com")
+    session.cookies.set("blog_language","ja", ".blog.fc2.com")
+    if use_cached:
+        if get_write_path(url, filename=record_filename).exists():
+            if no_read:
+                return True
+            return get_write_path(url, filename=record_filename).read_text(encoding="utf-8")
+
+    try:
+        response = await session.get(url,)
+    except httpx.TimeoutException:
+        return False # Error?
+    except idna.core.InvalidCodepoint:
+        print(f"What: {url}")
+        return f'<?xml version="1.0" encoding="utf-8"?><error>idna.core.InvalidCodepoint: {url}</error>'
+    except idna.core.InvalidCodepointContext:
+        print(f"What: {url}")
+        return f'<?xml version="1.0" encoding="utf-8"?><error>idna.core.InvalidCodepointContext {url}</error>'
+    except idna.core.IDNAError:
+        print(f"What: {url}")
+        return f'<?xml version="1.0" encoding="utf-8"?><error>idna.core.IDNAError: {url}</error>'
+    except Exception as e:
+        print(f"What: {url}", e)
+        return f'<?xml version="1.0" encoding="utf-8"?><error>Uncaught Error: {url}</error>'
+    if response.status_code in [200, 404]:
+        if record_func:
+            if inspect.isawaitable(record_func):
+                await record_func(response, filename=record_filename)
+            else:
+                record_func(response, filename=record_filename)
+        return response.text
+    elif response.status_code in [301, 302]:
+        redirected = response.headers.get('location')
+        if "https://error.fc2.com/" in redirected:
+            if "https://error.fc2.com/blog/e/404/" in redirected:
+                return '<?xml version="1.0" encoding="utf-8"?><error>404, does not exist.</error>'
+            if "https://error.fc2.com/blog/syntax_error/" in redirected:
+                return '<?xml version="1.0" encoding="utf-8"?><error>syntax_error for requested page.</error>'
+            if "https://error.fc2.com/" in redirected: 
+                print(f"Error: {response.status_code} for {response}: {redirected} | {url}")
+                return False # Error?
+            print(f"Error: {response.status_code} for {response}: {redirected} | {url}")
+            return False # Error?
+        else:
+            if redirected.startswith("/"):
+                redirected = urllib.parse.urlunparse(urllib.parse.urlparse(url)._replace(path=redirected))
+            if redirected.startswith("https://") or redirected.startswith("http://"):
+                # Https:// redirect
+                return await get_url(
+                    redirected, record_filename=record_filename,
+                    use_cached=use_cached, no_read=no_read, record_func=record_func)
+            else:
+                print(f"Error: {response.status_code} for {response}: {redirected} | {url}")
+                return False
+        #print(f"Error: {response.status_code} for {response}: {}")
+        #return False
+    elif response.status_code in [502, 503]:
+        # Retry on 502
+        return False
+    print(f"Error: {response.status_code} for {response}")
+    return False
+
+shlk = asyncio.Queue(maxsize=10000)
+
+from huggingface_hub import HfApi
+api = HfApi()
+
+def sync_upload(idx):
+    subprocess.call(["7zz", "a", f"/home/shinon/fc2Warui/BLiterature_{str(idx).zfill(2)}.7z", f"/home/shinon/fc2Warui/page_scrape_{idx}.jsonl"])
+    api.upload_file(
+        path_or_fileobj=f"/home/shinon/fc2Warui/BLiterature_{str(idx).zfill(2)}.7z",
+        path_in_repo=f"BLiterature_{str(idx).zfill(2)}.7z",
+        repo_id="RyokoAI-Internal/BLiterature",
+        repo_type="dataset",
+    )
+    print(f"Deleting parts: page_scrape_{idx}.jsonl | BLiterature_{str(idx).zfill(2)}.7z")
+    pathlib.Path(f"page_scrape_{idx}.jsonl").unlink()
+    pathlib.Path(f"BLiterature_{str(idx).zfill(2)}.7z").unlink()
+
+hf_upload_executor = ThreadPoolExecutor(10)
+
+async def hf_upload(idx):
+    loop = asyncio.get_running_loop()
+    await loop.run_in_executor(hf_upload_executor, sync_upload, idx)
+
+
+async def scrape_compiled_pages():
+    f = [str(f.resolve()) for f in pathlib.Path("pp").iterdir() if (f.is_file() and f.suffix.endswith(".jsonl"))]
+    f = natsorted(f, alg=ns.PATH)
+    f = [pathlib.Path(filepath) for filepath in f]
+
+    shared_queue = asyncio.Queue(maxsize=5000)
+    write_queue = asyncio.Queue(maxsize=5000)
+
+    executor = ThreadPoolExecutor(max_workers=4)
+
+    up_tasks = []
+
+    write_resume = 0
+    
+    async def write_thread():
+        rotation = 0
+        pbar = tqdm.tqdm(desc="Write Thread")
+        fs = await aiofiles.open(f"page_scrape_{rotation}.jsonl", "wb")
+        fs2 = await aiofiles.open(f"index.jsonl", "wb")
+        while True:
+            if write_queue.empty():
+                await asyncio.sleep(0.5)
+                continue
+            buffer = []
+            buffer2 = []
+            while not write_queue.empty():
+                q = await write_queue.get()
+                if q:
+                    r = await loop.run_in_executor(executor, orjson.dumps, q)
+                    buffer.append(r + b"\n")
+                    buffer2.append(q[0].encode() + b"\n")
+                pbar.update(1)
+                pbar.desc = f"Write Thread: {write_queue.qsize()}"
+            if buffer and buffer2:
+                await fs.write(b"".join(buffer))
+                await fs2.write(b"".join(buffer2))
+            n_rotation = pbar.n // 2500000
+            if n_rotation != rotation:
+                await fs.close()
+                if write_resume < n_rotation:
+                    up_tasks.append(loop.create_task(hf_upload(rotation)))
+                else:
+                    print("Not writing", f"page_scrape_{rotation}.jsonl")
+                rotation = n_rotation
+                fs = await aiofiles.open(f"page_scrape_{rotation}.jsonl", "wb")
+                
+        
+    if pathlib.Path("resume").exists():
+        start_from = int(pathlib.Path("resume").read_text())
+        write_resume = start_from // 2500000
+    else:
+        start_from = 0
+    pbaru = tqdm.tqdm(desc="Task Threads")
+    async def url_find():
+        while True:
+            if shared_queue.empty():
+                await asyncio.sleep(0.5)
+                continue
+            url = await shared_queue.get()
+            if url is not None:
+                await write_queue.put((url, await get_url(url, record_func=None, use_cached=False)))
+            else:
+                await write_queue.put(None)
+            #pbar.desc = "Task Thread: " + url.split("/")[-1] + f" {shared_queue.qsize()}"
+            pbaru.update(1)
+    loop = asyncio.get_running_loop()
+    tasks = [loop.create_task(url_find()) for _ in range(6000)] + [loop.create_task(write_thread())]
+    print(start_from, "start_from")
+    if start_from > 0:
+        print("resuming from:", start_from)
+    for file in f:
+        async with aiofiles.open(file,"r") as fp:
+            print(f"Process:", str(file))
+            async for line in fp:
+                #print(line)
+                try:
+                    load = await loop.run_in_executor(executor, orjson.loads, line)
+                except Exception as e:
+                    print("Eror whle loading json:", line, "error", e, "file", file)
+                url = load[1]
+                #print(url)
+                if "/blog-entry-" in url:
+                    #print(f"put {url}")
+                    if start_from > 0:
+                        url = None
+                        start_from -= 1
+                    await shared_queue.put(url)
+    
+    await asyncio.gather(*up_tasks)
+            
+        
+
+
+
+async def compile_pages():
+    
+    pbar = tqdm.tqdm(desc="Pages Parsed")
+    pbar2 = tqdm.tqdm(desc="Sites Parsed")
+    rotation = 0
+    fs = await aiofiles.open(f"pages_{rotation}.jsonl", "wb")
+    for blog_path in pathlib.Path("blog").iterdir():
+        lines = []
+        if blog_path.is_file():
+            continue
+        blog_path = blog_path / "sitemap.xml"
+        username = blog_path.parent.name
+        soup = BeautifulSoup(blog_path.read_text(encoding="utf-8", errors="ignore"),"lxml")
+        if soup.find("error"):
+            # Page probably does not exist.
+            return
+        for route in soup.find_all("loc"):
+            url = route.text
+            lines.append(orjson.dumps([username, url]) + b"\n")
+            pbar.update(1)
+        await fs.write(b"".join(lines))
+        pbar2.update(1)
+        n_rotation = pbar.n // 2500000
+        if n_rotation != rotation:
+            await fs.close()
+            rotation = n_rotation
+            fs = await aiofiles.open(f"pages_{rotation}.jsonl", "wb")
+    pbar.close()
+            
+
+async def blogs():
+    sem = asyncio.Semaphore(ASYNC_CALL)
+    links_t = set()
+    loop = asyncio.get_running_loop()
+    for community in range(6, 53):
+        html = list((ROOT / pathlib.Path(f"genre/{community}/ranking")).iterdir())
+        with tqdm.tqdm(total=len(html)) as pbar:
+            async def fetch_file(file:pathlib.Path):
+                async with sem:
+                    async with aiofiles.open(file,encoding="utf-8") as f:
+                        pbar.update(1)
+                        return await f.read()
+            tasks = [loop.create_task(fetch_file(fs)) for fs in html]
+            contents = await asyncio.gather(*tasks, return_exceptions=True)
+        print("Parsing")
+        with tqdm.tqdm(total=len(contents)) as pbar:
+            for content in contents:
+                soup = BeautifulSoup(content, "lxml")
+                for links in soup.select(".blogranking_title > a"):
+                    links_t.add(links['href'])
+                pbar.update(1)
+        del contents
+    (ROOT / "blogs.json").write_text(json.dumps(list(links_t), ensure_ascii=False, indent=2))
+
+async def blog_sitemaps():
+    sem = asyncio.Semaphore(ASYNC_CALL)
+    blogs = json.loads((ROOT / "blogs.json").read_text(encoding="utf-8"))
+    maps = [f"{blog}sitemaps.xml" for blog in blogs]
+    pbar = tqdm.tqdm(total=len(maps), smoothing=0.8)
+    def cond(url):
+        par = urllib.parse.urlparse(url)
+        username = par.netloc.split(".")[0]
+        fs=f"blog/{username}/sitemap.xml"
+        pbar.update(1)
+        if (ROOT / pathlib.Path(fs)).exists():
+            return False
+        return True
+    maps = [sitemap for sitemap in maps if cond(sitemap)]
+    pbar.close()
+
+    with tqdm.tqdm(total=len(maps), smoothing=0.8) as pbar:
+        async def scrape_page(url):
+            async with sem:
+                par = urllib.parse.urlparse(url)
+                username = par.netloc.split(".")[0]
+                await get_url(url, record_filename=f"blog/{username}/sitemap.xml", no_read=True, noisy=1)
+                pbar.update(1)
+        loop = asyncio.get_running_loop()
+        print("Creating tasks")
+        tasks = [loop.create_task(scrape_page(sitemap)) for sitemap in maps]
+        print("Task creation done. Requesting...")
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+
+async def genre():
+    """Scrapes public blogs via the ranking category.
+
+    """
+    #root = "https://blog.fc2.com"
+    #community_page = await get_url("https://blog.fc2.com/community/")
+    #soup = BeautifulSoup(community_page, "lxml")
+
+    #selects = soup.select("li.community_genre_item > a")
+    # https://blog.fc2.com/genre/52/ranking/
+    sem = asyncio.Semaphore(ASYNC_CALL)
+    for community in range(6, 53):
+        print(f"https://blog.fc2.com/genre/{community}/ranking/")
+        community_page = await get_url(f"https://blog.fc2.com/genre/{community}/ranking/")
+        if isinstance(community_page, bool):
+            raise Exception("Weird?")
+        soup = BeautifulSoup(community_page, "lxml")
+        pagers = soup.select("div.pager > div > a")
+        print(pagers)
+        last_ref = pagers[-1]['href']
+        if last_ref.startswith("/a/"): # Adult / Community 23 is... weird.
+            max_pg = int(last_ref.replace(f"/a/genre/ranking/","").split("/")[0])
+        else:
+            max_pg = int(last_ref.replace(f"/genre/{community}/ranking/","").split("/")[0])
+        shuffled_page = list(range(1,max_pg))
+        random.shuffle(shuffled_page)
+
+        with tqdm.tqdm(total=len(shuffled_page)) as pbar:
+            async def scrape_page(idx):
+                async with sem:
+                    url = f"https://blog.fc2.com/genre/{community}/ranking/{idx}"
+                    await get_url(url, no_read=True)
+                    pbar.update(1)
+            loop = asyncio.get_running_loop()
+            tasks = [loop.create_task(scrape_page(page)) for page in shuffled_page]
+            await asyncio.gather(*tasks)
+        
+
+
+async def communities():
+    root = "https://blog.fc2.com"
+    community_page = await get_url("https://blog.fc2.com/community/")
+    soup = BeautifulSoup(community_page, "lxml")
+    selects = soup.select("li.community_genre_item > a")
+    print(f"Found: {len(selects)} communities")
+    sem = asyncio.Semaphore(ASYNC_CALL)
+    for community in selects:
+        community_url = root + community['href']
+        print(f"comm_url: {community_url}")
+        community_page = await get_url(community_url)
+        soup = BeautifulSoup(community_page, "lxml")
+        pagers = soup.select("div.pager > div > a")
+        last_ref = pagers[-1]['href']
+        shuffled_page = list(range(1,int(last_ref.replace(community['href'],"").split("/")[1])))
+        random.shuffle(shuffled_page)
+        print(f"Max for shuffled_page: {max(shuffled_page)}")
+        with tqdm.tqdm(total=len(shuffled_page)) as pbar:
+            async def scrape_page(cat, idx):
+
+                async with sem:
+                    url = f"{community_url}/page/{idx}/?&order_by=member"
+                    if not (ROOT.resolve() / f"community/category/{cat}/{idx}").with_suffix(".html").exists():
+                        await get_url(url, record_filename=f"community/category/{cat}/{idx}", no_read=True)
+                    pbar.update(1)
+
+            loop = asyncio.get_running_loop()
+            tasks = [loop.create_task(scrape_page(community['href'].split("/")[-2], page)) for page in shuffled_page]
+            await asyncio.gather(*tasks)
+
+
+async def do():
+    #await communities()
+    #await genre()
+    await scrape_compiled_pages()
+    #await blog_sitemaps()
+    await session.aclose()
+
+
+if __name__ == "__main__":
+    asyncio.run(do())