reddit code

README.md

@@ -1,3 +1,2 @@
----
-license: mit
----
+# reddew
+Reddit Download and Datasets

nirmaan/minireddit/minireddit-creation.ipynb

@@ -0,0 +1,172 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code to create Mini-Reddit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "from garage.data import image_listing\n",
+    "from PIL import Image\n",
+    "from random import shuffle\n",
+    "import shutil\n",
+    "from tqdm import tqdm\n",
+    "import re\n",
+    "\n",
+    "import numpy as np\n",
+    "import math"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179443\n"
+     ]
+    }
+   ],
+   "source": [
+    "reddit_dir = Path(\"~/me/data/reddit\").expanduser()\n",
+    "assert reddit_dir.exists()\n",
+    "subreddit_dir = [d for d in reddit_dir.iterdir() if d.is_dir()]\n",
+    "image_files = image_listing.find_images(reddit_dir)\n",
+    "print(len(image_files))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "output_dir =  Path(\"~/me/data/reddit-tiny\").expanduser()\n",
+    "pcnt = 0.05\n",
+    "num_image_files = len(image_files)\n",
+    "num_out_files = int(math.ceil(pcnt*num_image_files))\n",
+    "shuffle(image_files)\n",
+    "num_out_files\n",
+    "output_dir.mkdir()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "8973"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_out_files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "  0%|          | 0/8973 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "writing: /Users/reeteshmukul/me/data/reddit-tiny/apocalypse/scheduleddeliv_v9jc7m.jpeg: 100%|██████████| 8973/8973 [41:31<00:00,  3.60it/s]           \n"
+     ]
+    }
+   ],
+   "source": [
+    "idx = 0\n",
+    "with tqdm(total=num_out_files) as pbar:\n",
+    "    \n",
+    "    while idx < num_image_files:\n",
+    "        f = Path(image_files[idx])\n",
+    "        idx = idx + 1\n",
+    "\n",
+    "        try:\n",
+    "            im = Image.open(f)\n",
+    "            size = im.size\n",
+    "            pixels = max(1, size[0]) * max(1, size[1])\n",
+    "\n",
+    "            if pixels > Image.MAX_IMAGE_PIXELS: continue\n",
+    "            nim = np.array(im)\n",
+    "            if len(nim.shape)!= 3 or nim.shape[-1] != 3 : continue\n",
+    "\n",
+    "            subreddit = f.relative_to(reddit_dir).parent\n",
+    "       \n",
+    "            dname = subreddit.name           \n",
+    "            dname = dname.lower()\n",
+    "            if \"porn\" in dname:\n",
+    "                dname = dname.replace(\"porn\", \"\")\n",
+    "\n",
+    "            subreddit_dir = output_dir / subreddit.parent / dname\n",
+    "\n",
+    "            if not subreddit_dir.exists():\n",
+    "                subreddit_dir.mkdir()\n",
+    "\n",
+    "            \n",
+    "            fname = f.stem\n",
+    "            fname = re.sub(r'\\W+', '', fname)\n",
+    "            fname = fname + f.suffix\n",
+    "            fname = fname.lower()\n",
+    "            outpath = (output_dir / subreddit_dir/f\"{fname}\").with_suffix(\".jpeg\")\n",
+    "\n",
+    "            im.save(outpath)\n",
+    "            im.close()\n",
+    "            pbar.set_description(f\"writing: {outpath}\")\n",
+    "            pbar.update(1)\n",
+    "            if(pbar.n == pbar.total) : break\n",
+    "        except Exception as e:\n",
+    "            pass"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

nirmaan/minireddit/minireddit.ipynb

@@ -0,0 +1,174 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Code to create Mini-Reddit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pathlib import Path\n",
+    "from garage.data import image_listing\n",
+    "from PIL import Image\n",
+    "from random import shuffle\n",
+    "import shutil\n",
+    "from tqdm import tqdm\n",
+    "import re\n",
+    "\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "179443\n"
+     ]
+    }
+   ],
+   "source": [
+    "reddit_dir = Path(\"~/me/data/reddit\").expanduser()\n",
+    "assert reddit_dir.exists()\n",
+    "subreddit_dir = [d for d in reddit_dir.iterdir() if d.is_dir()]\n",
+    "image_files = image_listing.find_images(reddit_dir)\n",
+    "print(len(image_files))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_minireddit(pcnt=0.1):\n",
+    "    pcnt = 0.1\n",
+    "    output_dir =  Path(\"~/me/data/minireddit\").expanduser()\n",
+    "\n",
+    "    if output_dir.exists() : return\n",
+    "    \n",
+    "    output_dir.mkdir()\n",
+    "\n",
+    "    pbar = tqdm(subreddit_dir)\n",
+    "\n",
+    "    total_files = 0\n",
+    "\n",
+    "    for d in pbar:\n",
+    "        sub_files = [f for f in d.iterdir() if f.is_file()]\n",
+    "        shuffle(sub_files)\n",
+    "        if not sub_files: continue\n",
+    "        pnum = int(pcnt*len(sub_files))\n",
+    "        if pnum == 0: continue\n",
+    "\n",
+    "        sub_output_dir = output_dir / (d.stem)\n",
+    "\n",
+    "        if sub_output_dir.exists():\n",
+    "            total_files = total_files + len([f for f in sub_output_dir.iterdir() if f.is_file()])\n",
+    "        else:\n",
+    "            sub_output_dir.mkdir()\n",
+    "            idx = 0\n",
+    "\n",
+    "            for f in sub_files:\n",
+    "                try:\n",
+    "                    im = Image.open(f)\n",
+    "                    size = im.size\n",
+    "                    pixels = max(1, size[0]) * max(1, size[1])\n",
+    "                    if pixels > Image.MAX_IMAGE_PIXELS: continue\n",
+    "                    im.save((sub_output_dir/f\"{f.stem}\").with_suffix(\".jpeg\"))\n",
+    "                    im.close()\n",
+    "                    idx = idx + 1\n",
+    "                    total_files = total_files + 1\n",
+    "                    if idx >= pnum: break\n",
+    "                except Exception as e:\n",
+    "                    #print(e)\n",
+    "                    pass\n",
+    "        pbar.set_description(f\"Num Files = {total_files}\")\n",
+    "\n",
+    "    sub_output_dirs = [d for d in output_dir.iterdir()]\n",
+    "    for d in sub_output_dirs:\n",
+    "        dname = d.stem.lower()\n",
+    "        if \"porn\" in dname:\n",
+    "            dname = dname.replace(\"porn\", \"\")\n",
+    "        \n",
+    "        if dname != d.stem:\n",
+    "            d.rename(dname)\n",
+    "    \n",
+    "    sub_output_dirs = [d for d in output_dir.iterdir() if d.is_dir()]\n",
+    "    for d in sub_output_dirs:\n",
+    "        for f in d.iterdir():\n",
+    "            if not f.is_file():\n",
+    "                continue\n",
+    "            else:\n",
+    "                fname = f.stem\n",
+    "                fname = re.sub(r'\\W+', '', fname)\n",
+    "                fname = fname + f.suffix\n",
+    "                fname = fname.lower()\n",
+    "                if fname != f.name:\n",
+    "                    f.rename(d/fname)\n",
+    "\n",
+    "create_minireddit()\n",
+    "\n",
+    "def clean_iamge_files():\n",
+    "    pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "minreddit_dir =  Path(\"~/me/data/minireddit\").expanduser()\n",
+    "sub_mr_dirs = [d for d in minreddit_dir.iterdir() if d.is_dir()]\n",
+    "\n",
+    "for d in sub_mr_dirs:\n",
+    "    for f in d.iterdir():\n",
+    "        if not f.is_file():\n",
+    "            continue\n",
+    "        else:\n",
+    "            if \".DS_Store\" in f.name:\n",
+    "                f.unlink()\n",
+    "                continue\n",
+    "            try:\n",
+    "                im = np.array(Image.open(f))\n",
+    "                if (len(im.shape)!=3) or (im.shape[-1] !=3):\n",
+    "                    print(im.shape)\n",
+    "                    f.unlink()\n",
+    "            except:\n",
+    "                continue"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

nirmaan/preddit/preddit.ipynb

@@ -0,0 +1,242 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "from pathlib import Path\n",
+    "import os\n",
+    "import zipfile"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def archive_reddit(reddit_dir: os.PathLike, archive_dir: os.PathLike, archive_size = 3*(2**30))->pd.DataFrame:\n",
+    "    reddit_csv_path = reddit_dir/\"reddit.csv\"\n",
+    "    rdf = pd.read_csv(reddit_csv_path)\n",
+    "\n",
+    "    rdf = rdf.drop(columns=[\"wallpaper_dir\"])\n",
+    "    archive_csv_path = archive_dir/\"preddit.csv\"\n",
+    "    archive_dir.mkdir(exist_ok=True)\n",
+    "\n",
+    "    columns = ['index', 'os_type', 'title', 'url', 'subreddit']\n",
+    "\n",
+    "\n",
+    "    if archive_csv_path.exists():\n",
+    "        prdf = pd.read_csv(archive_csv_path)\n",
+    "    else:\n",
+    "        prdf = pd.DataFrame(columns= columns + ['archive'])\n",
+    "        prdf.to_csv(archive_csv_path, index=False)\n",
+    "    \n",
+    "    prdf = pd.merge(prdf, rdf, how=\"right\",  left_on=columns, right_on=columns)\n",
+    "    prdf.to_csv(archive_csv_path, index=False)\n",
+    "\n",
+    "    while True:\n",
+    "        archive_csv_path = archive_dir/\"preddit.csv\"\n",
+    "\n",
+    "        prdf = pd.read_csv(archive_csv_path)\n",
+    "        tdf = prdf[prdf[\"archive\"].isnull()]\n",
+    "\n",
+    "        max_ar = prdf[\"archive\"].max()\n",
+    "\n",
+    "        if np.isnan(max_ar):\n",
+    "            max_ar = 0\n",
+    "        else:\n",
+    "            max_ar = int(max_ar) + 1\n",
+    "        \n",
+    "        total_file_size = 0\n",
+    "        curr_archive_list = [ ]\n",
+    "\n",
+    "\n",
+    "        for idx, row in tdf.iterrows():\n",
+    "        \n",
+    "            subreddit_dir = reddit_dir / str(row[\"subreddit\"])\n",
+    "            findex = row[\"index\"]\n",
+    "            files = [f for f in subreddit_dir.glob(f\"*{findex}*\")]\n",
+    "\n",
+    "            if not files: continue\n",
+    "\n",
+    "            imfile : Path = files[0]\n",
+    "            fsize = imfile.stat().st_size\n",
+    "            \n",
+    "            if total_file_size + fsize > archive_size:\n",
+    "                break\n",
+    "            else:\n",
+    "                total_file_size = total_file_size + fsize\n",
+    "                curr_archive_list.append((idx, imfile))\n",
+    "            \n",
+    "        if 2*total_file_size < archive_size: break    \n",
+    "        archive_name = archive_dir / f\"reddit-{max_ar}.zip\"\n",
+    "\n",
+    "        \n",
+    "        print(f\"Writing Zip File {archive_name}\")\n",
+    "\n",
+    "        with zipfile.ZipFile(archive_name, 'w') as redditz:        \n",
+    "            for (idx, ifile) in curr_archive_list:\n",
+    "                redditz.write(ifile, Path(\"reddit\")/ifile.parent.name/ifile.name, compress_type=zipfile.ZIP_DEFLATED)\n",
+    "        \n",
+    "        print(f\"Written Zip File {archive_name}\")\n",
+    "\n",
+    "        for (idx, ifile) in curr_archive_list:\n",
+    "            prdf.at[idx, \"archive\"] = max_ar\n",
+    "        \n",
+    "\n",
+    "        prdf.to_csv(archive_csv_path)\n",
+    "\n",
+    "    return prdf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-3.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-3.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-4.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-4.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-5.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-5.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-6.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-6.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-7.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-7.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-8.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-8.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-9.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-9.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-10.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-10.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-11.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-11.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-12.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-12.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-13.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-13.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-14.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-14.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-15.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-15.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-16.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-16.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-17.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-17.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-18.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-18.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-19.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-19.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-20.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-20.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-21.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-21.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-22.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-22.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-23.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-23.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-24.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-24.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-25.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-25.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-26.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-26.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-27.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-27.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-28.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-28.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-29.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-29.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-30.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-30.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-31.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-31.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-32.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-32.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-33.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-33.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-34.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-34.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-35.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-35.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-36.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-36.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-37.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-37.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-38.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-38.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-39.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-39.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-40.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-40.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-41.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-41.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-42.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-42.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-43.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-43.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-44.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-44.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-45.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-45.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-46.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-46.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-47.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-47.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-48.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-48.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-49.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-49.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-50.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-50.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-51.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-51.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-52.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-52.zip\n",
+      "Writing Zip File /Users/reeteshmukul/me/data/preddit/reddit-53.zip\n",
+      "Written Zip File /Users/reeteshmukul/me/data/preddit/reddit-53.zip\n"
+     ]
+    }
+   ],
+   "source": [
+    "reddit_dir = Path(\"~/me/data/reddit\").expanduser()\n",
+    "preddit_dir = Path(\"~/me/data/preddit\").expanduser()\n",
+    "\n",
+    "prdf = archive_reddit(reddit_dir, preddit_dir)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.2"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

nirmaan/subreddit.ipynb

@@ -0,0 +1,291 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import urllib3\n",
+    "import json\n",
+    "from bs4 import BeautifulSoup\n",
+    "import numpy as np\n",
+    "from concurrent.futures import ThreadPoolExecutor\n",
+    "from concurrent.futures import Future\n",
+    "from traitlets import List\n",
+    "\n",
+    "from reddit.reddit_info import subreddit_name_l, subreddit_sort_l, subreddit_t_l\n",
+    "import itertools\n",
+    "import random\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "from datetime import datetime, timezone\n",
+    "from typing import Optional\n",
+    "from requests.utils import requote_uri\n",
+    "from random_word import RandomWords\n",
+    "from wonderwords import RandomSentence"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_subreddit_url(subreddit, sort_by:str = \"hot\", sort_time:str=\"all\", limit:int=100, query:Optional[str]=None):\n",
+    "    if not query:\n",
+    "        return f'https://www.reddit.com/r/{subreddit}/{sort_by}/.json?raw_json=1&t={sort_time}&limit={limit}'\n",
+    "    else:\n",
+    "        return f'https://www.reddit.com/r/{subreddit}/search/.json?raw_json=1&q={query}&limit={100}'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subreddit_url = get_subreddit_url(\"CityPorn\", \"hot\", \"all\", 100)#, query=\"6 years ago\")\n",
+    "subreddit_url = requote_uri(subreddit_url)\n",
+    "subreddit_url"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "user_agent = {'user-agent': 'Mozilla/5.0 (Windows NT 6.3; rv:36.0) ..'}\n",
+    "pool_manager = urllib3.PoolManager(headers=user_agent)\n",
+    "res = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fetch_subreddit_image_entries(subreddit_url: str, pool_manager):\n",
+    "    result = [ ]\n",
+    "    try:\n",
+    "        response = pool_manager.request('GET', subreddit_url)\n",
+    "        #print(response.data)\n",
+    "        subreddit_data = json.loads(response.data)        \n",
+    "        \n",
+    "        if not \"data\" in subreddit_data: return []\n",
+    "        if not \"children\" in subreddit_data[\"data\"]: return []\n",
+    "               \n",
+    "        for content in subreddit_data['data']['children']:\n",
+    "            try:\n",
+    "                if content['data'].get('post_hint', 'none') == 'image' and 'preview' in content['data']:                    \n",
+    "                    created_utc = datetime.fromtimestamp(content['data'][\"created_utc\"], timezone.utc)\n",
+    "                    \n",
+    "                    #print(created_utc)\n",
+    "                    \n",
+    "                    source_d = content['data']['preview']['images'][0]['source']\n",
+    "                    image_url, width, height = source_d['url'], source_d[\"width\"], source_d[\"height\"]\n",
+    "                    image_title = content['data']['title']\n",
+    "                    image_id = content['data']['id']\n",
+    "                    data_url = content['data']['url']\n",
+    "                    subreddit = content['data']['subreddit']\n",
+    "                    if content['data']['is_video'] : continue                    \n",
+    "                    result.append({\n",
+    "                        \"image_url\" : image_url,\n",
+    "                        \"title\" : image_title,\n",
+    "                        \"image_id\" : image_id,\n",
+    "                        \"url\" : data_url,\n",
+    "                        \"subreddit\" : subreddit,\n",
+    "                        \"width\" : width,\n",
+    "                        \"height\" : height,\n",
+    "                        \"created_utc\" : created_utc,\n",
+    "                    })\n",
+    "            except Exception as e:\n",
+    "                pass\n",
+    "        return result\n",
+    "    except Exception as e:\n",
+    "        #print(e)\n",
+    "        return []\n",
+    "    \n",
+    "#fetch_subreddit_image_entries(subreddit_url, pool_manager)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def fetch_multiple_subreddit_image_entries(subreddit_urls: str, thread_pool_size: int=5, urllib_pool_size:int=5):\n",
+    "    \n",
+    "    pool_manager = urllib3.PoolManager(maxsize=urllib_pool_size)\n",
+    "    thread_pool = ThreadPoolExecutor(thread_pool_size)\n",
+    "    res_futs = [ ]\n",
+    "    \n",
+    "    for subreddit_url in subreddit_urls:\n",
+    "        res_futs.append(thread_pool.submit(fetch_subreddit_image_entries, subreddit_url, pool_manager))\n",
+    "    \n",
+    "    res :[List[Future]] = []\n",
+    "        \n",
+    "    for r in res_futs:\n",
+    "        res.extend(r.result())\n",
+    "            \n",
+    "    return list({x[\"image_id\"] : x for x in res}.values())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_random_subreddit_urls(num_urls:int = 20):\n",
+    "    subr_l = list(itertools.product(subreddit_name_l, subreddit_sort_l, subreddit_t_l))\n",
+    "    return [get_subreddit_url(*xs, 100) for xs in random.sample(subr_l, k=num_urls)]\n",
+    "\n",
+    "def get_random_subreddit_query_urls(num_urls:int = 20, query_type: str = \"chronology\"):\n",
+    "    '''\n",
+    "        query_type:\n",
+    "            chronology\n",
+    "            random_word\n",
+    "            random_phrase\n",
+    "    '''\n",
+    "    timeline = random.choices([\"days\", \"months\", \"years\"], k = num_urls)\n",
+    "    timevalue = random.choices(range(1, 12), k = num_urls)\n",
+    "    subr = random.sample(subreddit_name_l, k = num_urls)\n",
+    "    \n",
+    "    if query_type == \"chronology\":\n",
+    "        return [get_subreddit_url(subreddit=sr, query=f\"{tv} {tl} ago\") for (sr, tl, tv) in list(itertools.product(subr, timeline, timevalue))]\n",
+    "    elif query_type == \"random_word\":\n",
+    "        r = RandomWords()\n",
+    "        return [get_subreddit_url(subreddit=sr, query=f\"{r.get_random_word()}\") for sr in subr]\n",
+    "    elif query_type == \"random_phrase\":\n",
+    "        s = RandomSentence()\n",
+    "        return [get_subreddit_url(subreddit=sr, query=f\"{s.sentence()}\") for sr in subr]\n",
+    "    else:\n",
+    "        return [ ] \n",
+    "\n",
+    "\n",
+    "\n",
+    "#get_random_subreddit_urls()    \n",
+    "#get_random_subreddit_query_urls(query_type=\"random_phrase\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#subreddit_url = get_random_subreddit_query_urls(num_urls=5)[2]\n",
+    "#subreddit_url = get_subreddit_url(\"CityPorn\", \"hot\", \"all\", 100, query=\"11 years ago\")\n",
+    "#fetch_subreddit_image_entries(subreddit_url, pool_manager)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#res = fetch_multiple_subreddit_image_entries(get_random_subreddit_urls(num_urls=100))\n",
+    "#res = fetch_multiple_subreddit_image_entries(get_random_subreddit_query_urls(num_urls=5))\n",
+    "#len(res)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "policies = [\n",
+    "    (\"subredit_sort\", lambda: fetch_multiple_subreddit_image_entries(get_random_subreddit_urls(num_urls=100))),\n",
+    "    (\"subreddit_chrono\", lambda: get_random_subreddit_query_urls(num_urls=5, query_type=\"chronology\")),\n",
+    "    (\"subreddit_random_word\", lambda: get_random_subreddit_query_urls(num_urls=5, query_type=\"random_word\")),\n",
+    "    (\"subreddit_random_phrase\", lambda: get_random_subreddit_query_urls(num_urls=5, query_type=\"random_phrase\")),\n",
+    "]\n",
+    "\n",
+    "policy_count = [[]]*len(policies)\n",
+    "policy_hit = [[]]*len(policies)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dfname = \"reddit.csv\"\n",
+    "otime = 0\n",
+    "\n",
+    "tarr = []\n",
+    "karr = []\n",
+    "\n",
+    "total_updates = 0\n",
+    "\n",
+    "with tqdm(total=10000) as pbar:\n",
+    "    for _  in range(10000):\n",
+    "        if random.random() > 0.6:\n",
+    "            res = fetch_multiple_subreddit_image_entries(get_random_subreddit_urls(num_urls=100))\n",
+    "        else:\n",
+    "            res = fetch_multiple_subreddit_image_entries(get_random_subreddit_query_urls(num_urls=5, query_type=\"random_phrase\"))\n",
+    "        \n",
+    "        num_fetched = len(res)\n",
+    "        \n",
+    "        if res:\n",
+    "            if not Path(dfname).exists():\n",
+    "                pd.DataFrame(res).to_csv(dfname, index=False)\n",
+    "                karr.append(len(res))\n",
+    "            else:\n",
+    "                df = pd.read_csv(dfname)\n",
+    "                keys = set(df[\"image_id\"])\n",
+    "                cres = [x for x in res if not (x[\"image_id\"] in keys)]\n",
+    "                \n",
+    "                if cres:\n",
+    "                    ndf = pd.DataFrame(cres)\n",
+    "                    ndf.to_csv(dfname, mode=\"a\", header=None, index=False)\n",
+    "                karr.append(len(cres))\n",
+    "        else:\n",
+    "            karr.append(0)\n",
+    "                \n",
+    "        ntime = pbar.format_dict['elapsed']\n",
+    "        N = len(pd.read_csv(dfname))\n",
+    "        tarr.append(ntime-otime)\n",
+    "        otime = ntime\n",
+    "        tarr = tarr[-25:]\n",
+    "        karr = karr[-25:]\n",
+    "        rate = sum(karr)/sum(tarr)\n",
+    "        pbar.update(1)\n",
+    "        total_updates = total_updates + karr[-1]\n",
+    "        pbar.set_description_str(f\"count:{N}, fetch rate:{rate:.3f}, last_update:{karr[-1]}, total_updates:{total_updates}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

reddit/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Sarjak Thakkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reddit/README.md

@@ -0,0 +1,58 @@
+# Download Images and Set Wallpapers from your choice of Subreddit!
+
+Using this script:
+* **No Setup Needed!**
+* **Download any number of images** from **Any Subreddit!**
+* Select your sort type **(Top, Hot, New, Controversial)**
+* Select your sort time **(All, Year, Month, Week, Day)**
+* Extremely **Reliable Downloading.**
+* **Automatically set and switch Wallpaper** from the downloaded images
+* **Store the links** to all the downloaded images (in case you want to access later?)
+* Works on **Python 2.x and Python 3.x** both!
+* Specify your **custom save location**!
+
+### Grab the latest release here! Or download it using the next step!
+DownloadRedditImages v2.0.0 - https://github.com/tsarjak/WallpapersFromReddit/releases/tag/v2.0.0
+
+### No Dependencies! Just Download and Run!
+Just download the files and run the file - no need to setup anything at all!
+
+To download via Terminal:
+```shell
+git clone https://github.com/tsarjak/WallpapersFromReddit.git
+```
+
+
+### To run the code
+
+In terminal:
+```shell
+# In the Home Directory or the Directory in which you cloned/downloaded the script
+cd ~/DownloadRedditImages
+python main.py 
+  --subreddit <your choice of subreddit> 
+  --sort_type <hot|new|rising|top> 
+  --sort_time <all|year|month|week|day>
+  --save_dir <Directory where you want to store the images. By default it saves in wallpapers folder>
+  --update_every <Number of minutes after which you want to change the wallpapers>
+  --run_for <Total number of hours you want to run the script for>
+  --download_only <Toggle this to either only download the images, or to also keep cycling throught the wallpapers>
+```
+
+Example: 
+```shell
+python wallpaper.py --subreddit earthporn -sort_type top --sort_time all --download_only
+```
+
+
+### After First run, you might want to run the app in background (This is possible even on first run!)
+
+```shell
+nohup python main.py &
+```
+nohup command is used to keep the script running in background, even when the terminal is closed
+
+### Add the script to run it as startup application
+
+Goto "Startup Applications"
+Click "Add" -> Click "Custom Command" -> Enter command as "nohup python ~/main.py &", enter name and other details and save

reddit/__init__.py

@@ -0,0 +1,2 @@
+from .redditd import rdownloader
+from .subreddits import SUBREDDITS

reddit/core.py

@@ -0,0 +1,162 @@
+import os
+from typing import Dict
+
+import requests
+
+from .utils import Utils
+from os import path as osp
+from pathlib import Path
+import pandas as pd
+import concurrent
+
+class WallpaperDownloader:
+    """
+    Core class to download images from Reddit.
+    """
+
+    def __init__(self,
+                 subreddit: str = 'wallpaper',
+                 sort_by: str = 'top',
+                 sort_time: str = 'all',
+                 save_dir: str = 'default'):
+        """
+        Initialize the preference and link to subreddit.
+        :param subreddit: Name of the subreddit.
+        :param sort_by: Sort by? Hot/Top/New/Controversial.
+        :param sort_time: Sort time. day/week/month/year/all
+        """
+        self._url = 'https://www.reddit.com/r/{}/{}/.json?raw_json=1&t={}&limit=100'.format(subreddit,
+                                                                                  sort_by,
+                                                                                  sort_time)
+        self._preferences_file = Path(save_dir) / 'wp_preferences.json'
+        self._preferences = self._setup_preferences(save_dir=save_dir)
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=16)
+
+    @property
+    def preferences(self) -> Dict:
+        """
+        Get the preferences.
+        :return: Preferences Dict.
+        """
+        return Utils.load_preferences(self._preferences_file)
+    
+    @staticmethod
+    def download_image(image_url, img_save_name): 
+        
+        if osp.exists(img_save_name):
+            return
+        
+        dummy_img_save_name = img_save_name + ".dummy"        
+              
+        with requests.get(image_url, stream=True) as r:
+            r.raise_for_status()
+            with open('{}'.format(img_save_name), 'wb') as f:
+                for chunk in r.iter_content(chunk_size=26214400):
+                    if chunk:
+                        f.write(chunk)       
+        
+        if osp.exists(dummy_img_save_name):
+            osp.remove(dummy_img_save_name)
+    
+    def download(self, max_count: int = 200):
+        """
+        This is where all the downloading takes place.
+        :param max_count: Maximum number of images to download.
+        :return: num_downloaded: Number of downloaded images.
+        """
+
+        # Update URL to fetch entries based on max_count.
+        self._url += '&limit={}'.format(
+            max_count * 1000)  # There are a lot of unwanted images, so setting it to high value.
+
+        # Fetch the JSON file for subreddit here.
+        subreddit_data = Utils.fetch_subreddit_data(subreddit_url=self._url)
+
+        # If we can't get subreddit data even after 20 trials, we close the program. Try later.
+        if subreddit_data is None:
+            #print('Unable to connect to reddit. Check internet connection. Or try later.')
+            return 0
+
+        count = 0
+        saved_images = []
+
+        for content in subreddit_data['data']['children']:
+
+            if content['data'].get('post_hint', 'none') == 'image' and 'preview' in content['data']:
+                # Get the information about the image.
+                image_url = content['data']['preview']['images'][0]['source']['url']
+                image_title = content['data']['title'][:15]
+                image_title = ''.join(filter(str.isalnum, image_title))
+                image_id = content['data']['id']
+
+                # Set image save name
+                img_save_name = '{}_{}.jpg'.format(image_title, image_id)
+                img_save_name = osp.join(self._preferences['wallpaper_dir'], img_save_name)
+
+
+                dummy_img_save_name = img_save_name + ".dummy"
+                # If we have already downloaded the image, we can skip.
+                if osp.exists(img_save_name):
+                    continue
+                                
+                open(img_save_name, 'a').close()
+                os.utime(img_save_name, None)
+
+                # Actually downloading the image.
+                try:
+                    #self.executor.submit(WallpaperDownloader.download_image, image_url, img_save_name)
+                    '''
+                    with requests.get(image_url, stream=True) as r:
+                        r.raise_for_status()
+                        with open('{}'.format(img_save_name), 'wb') as f:
+                            for chunk in r.iter_content(chunk_size=26214400):
+                                if chunk:
+                                    f.write(chunk)
+                    '''
+                except:
+                    continue
+
+                saved_images.append(img_save_name)
+
+                # Update the preferences.
+                self._preferences['urls'][image_id] = {'title': image_title,
+                                                       'url': image_url}
+                Utils.save_to_preferences(self._preferences, self._preferences_file)
+
+                count += 1
+
+            # Done downloading, so remove unwanted images and return the total number of saved images.
+            if count >= max_count:
+                count_removed = Utils.remove_unwanted_images(saved_images)
+                return len(saved_images) - count_removed
+
+        return count
+
+    def _setup_preferences(self, save_dir='default') -> Dict:
+        """
+        Setup the preferences for downloading. Find the machine type etc if its running for the first time.
+        :return: preferences - Loaded preferences.
+        """
+        # Load the preferences file.
+        preferences = Utils.load_preferences(self._preferences_file) if osp.exists(self._preferences_file) else {}
+
+        # If it's empty (running for the first time), we set it up manually.
+        if preferences == {}:
+            os_type, wallpaper_dir = Utils.get_os()
+
+            # If wallpapers directory is not there, we create it.
+            if not osp.exists(wallpaper_dir):
+                os.makedirs(wallpaper_dir)
+
+            preferences['os_type'] = os_type
+            preferences['wallpaper_dir'] = wallpaper_dir
+            preferences['urls'] = dict()
+
+        # Update the default dir here.
+        if save_dir != 'default':
+            preferences['wallpaper_dir'] = save_dir
+
+        # Just save preferences back to file in case of update.
+        Utils.save_to_preferences(preferences, self._preferences_file)
+
+        return preferences

reddit/reddit_info.py

@@ -0,0 +1,211 @@
+subreddit_name_l = list(dict.fromkeys([
+    'BollywoodUHQonly',
+    
+    'Wallpapers',
+    'wallpaper',
+
+    'CityPorn', 
+    'VillagePorn', 
+    'RuralPorn', 
+    'ArchitecturePorn', 
+    'HousePorn', 
+    'CabinPorn', 
+    'ChurchPorn', 
+    'AbandonedPorn', 
+    'CemeteryPorn', 
+    'InfrastructurePorn', 
+    'MachinePorn', 
+    'carporn', 
+    'F1Porn', 
+    'MotorcyclePorn', 
+    'MilitaryPorn', 
+    'GunPorn', 
+    'KnifePorn', 
+    'BoatPorn', 
+    'RidesPorn', 
+    'DestructionPorn', 
+    'ThingsCutInHalfPorn', 
+    'StarshipPorn', 
+    'ToolPorn', 
+    'TechnologyPorn', 
+    'BridgePorn', 
+    'PolicePorn', 
+    'SteamPorn', 
+    'RetailPorn', 
+    'SpaceFlightPorn', 
+    'roadporn', 
+    'drydockporn',
+    'AnimalPorn', 
+    'HumanPorn', 
+    'EarthlingPorn', 
+    'AdrenalinePorn', 
+    'ClimbingPorn', 
+    'SportsPorn', 
+    'AgriculturePorn', 
+    'TeaPorn', 
+    'BonsaiPorn', 
+    'FoodPorn', 
+    'CulinaryPorn', 
+    'DessertPorn',
+    'DesignPorn', 
+    'RoomPorn', 
+    'AlbumArtPorn', 
+    'MetalPorn',
+    'MoviePosterPorn', 
+    'TelevisionPosterPorn', 
+    'ComicBookPorn', 
+    'StreetArtPorn', 
+    'AdPorn', 
+    'ArtPorn', 
+    'FractalPorn', 
+    'InstrumentPorn', 
+    'ExposurePorn', 
+    'MacroPorn', 
+    'MicroPorn', 
+    'GeekPorn', 
+    'MTGPorn', 
+    'GamerPorn', 
+    'PowerWashingPorn', 
+    'AerialPorn', 
+    'OrganizationPorn', 
+    'FashionPorn', 
+    'AVPorn', 
+    'ApocalypsePorn', 
+    'InfraredPorn', 
+    'ViewPorn', 
+    'HellscapePorn', 
+    'sculptureporn',
+
+    'HighResPrints',
+    'SpaceWallpapers',
+    
+    'ArtefactPorn',
+    'MegalithPorn',
+    'FossilPorn',
+    'FuturePorn',
+    'QuotesPorn',
+    'NewsPorn',
+    'BookPorn',
+    'UniformPorn',
+    'HistoryPorn',   
+    'AutumnPorn',
+    'EarthPorn',
+    'SkyPorn',
+    'SeaPorn',
+    'WeatherPorn',
+    'BotanicalPorn',
+    'LakePorn',
+    'BeachPorn',
+    'WaterPorn',
+    'SpacePorn',
+    'FirePorn',
+    'DesertPorn',
+    'WinterPorn',
+    'GeologyPorn',
+    'MushroomPorn',
+    'SpringPorn',
+    'SummerPorn',
+    'LavaPorn',
+    'multiwall',
+    'offensive_wallpapers',
+    'HI_Res',
+    'Forest',
+    'ArtFundamentals',
+    'Art',
+    'HighResCelebs',
+    'CelebEvents',
+    'UltraHighResCelebs',
+    'UHQcelebs',
+    'celebrityboners',
+    'HRCelebs',
+    'UHQDesi',
+    '4kcelebs',
+    'UltraHighResBollywood',
+    'Astronomy',
+    'MakeupAddiction',
+    'ultrahdwallpapers',
+    'FlowerPorn',
+    'mountainporn',
+    'RiverPorn',
+    'F1Porn',
+    'jameswebb',
+    'randomsexiness',
+    'gentlemanboners',
+    'BeautifulFemales',
+    'RoyalWarReport',
+    'DesiPetiteCelebs',
+    'travelphotos',
+    'IncredibleIndia',
+    'interestingasfuck',
+    'MuseumPorn',
+    'Fruitgore',
+    'FestivalSluts',
+    'festivals',
+    'AlternateAngles',
+    'ColorizedHistory',
+    'MoviemaniaHQ',
+    'IndianFoodPhotos',
+
+    'surrealism',
+
+    'Comics',
+    'SpecArt',
+    
+    'WTF',
+
+    'OldSchoolCool',
+
+    'pics',
+    'wwiipics',
+    'travelpics',
+
+    'photography',
+    'fashionphotography',
+    'productphotography',
+    'travelphotography',
+
+    'photocritique',
+    'itookapicture',
+    'PictureChallenge',
+    'photoit',
+    'postprocessing',
+
+
+    'outside',
+
+    'TheWayWeWere',
+
+    'Cinemagraphs',
+
+    'BlackPeopleTwitter',
+
+    'WtSSTaDaMiT',
+
+    'Eyebleach',
+
+    'me_irl',
+
+    'Posters',
+    'PropagandaPosters',
+    'PlexPosters',
+
+    'painting',
+]))
+
+
+subreddit_sort_l = [
+    "hot",
+    "new",
+    "top",
+    "controversial",
+    "rising",
+]
+
+subreddit_t_l = [
+    "hour", 
+    "day", 
+    "week", 
+    "month", 
+    "year", 
+    "all",
+]

reddit/reddit_processor.py

@@ -0,0 +1,163 @@
+import os
+import pandas as pd
+import urllib3
+import json
+from bs4 import BeautifulSoup
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import Future
+from traitlets import List
+
+from reddit.reddit_info import subreddit_name_l, subreddit_sort_l, subreddit_t_l
+import itertools
+import random
+from pathlib import Path
+
+from tqdm import tqdm
+
+from datetime import datetime, timezone
+from typing import Any, Optional
+from requests.utils import requote_uri
+from random_word import RandomWords
+from wonderwords import RandomSentence
+
+
+class RedditProcessor:
+    def get_subreddit_url(self, subreddit, sort_by:str = "hot", sort_time:str="all", limit:int=100, query:Optional[str]=None):
+        if not query:
+            return f'https://www.reddit.com/r/{subreddit}/{sort_by}/.json?raw_json=1&t={sort_time}&limit={limit}'
+        else:
+            return f'https://www.reddit.com/r/{subreddit}/search/.json?raw_json=1&q={query}&limit={100}'
+    
+    
+    def fetch_subreddit_image_entries(self, subreddit_url: str, pool_manager):
+        result = [ ]
+        try:
+            response = pool_manager.request('GET', subreddit_url)
+            #print(response.data)
+            subreddit_data = json.loads(response.data)        
+            
+            if not "data" in subreddit_data: return []
+            if not "children" in subreddit_data["data"]: return []
+                
+            for content in subreddit_data['data']['children']:
+                try:
+                    if content['data'].get('post_hint', 'none') == 'image' and 'preview' in content['data']:                    
+                        created_utc = datetime.fromtimestamp(content['data']["created_utc"], timezone.utc)
+                        
+                        #print(created_utc)
+                        
+                        source_d = content['data']['preview']['images'][0]['source']
+                        image_url, width, height = source_d['url'], source_d["width"], source_d["height"]
+                        image_title = content['data']['title']
+                        image_id = content['data']['id']
+                        data_url = content['data']['url']
+                        subreddit = content['data']['subreddit']
+                        if content['data']['is_video'] : continue                    
+                        result.append({
+                            "image_url" : image_url,
+                            "title" : image_title,
+                            "image_id" : image_id,
+                            "url" : data_url,
+                            "subreddit" : subreddit,
+                            "width" : width,
+                            "height" : height,
+                            "created_utc" : created_utc,
+                        })
+                except Exception as e:
+                    pass
+            return result
+        except Exception as e:
+            #print(e)
+            return []
+    
+    
+    def fetch_multiple_subreddit_image_entries(self, subreddit_urls: str, thread_pool_size: int=5, urllib_pool_size:int=5):
+    
+        pool_manager = urllib3.PoolManager(maxsize=urllib_pool_size)
+        thread_pool = ThreadPoolExecutor(thread_pool_size)
+        res_futs = [ ]
+        
+        for subreddit_url in subreddit_urls:
+            res_futs.append(thread_pool.submit(self.fetch_subreddit_image_entries, subreddit_url, pool_manager))
+        
+        res :[List[Future]] = []
+            
+        for r in res_futs:
+            res.extend(r.result())
+                
+        return list({x["image_id"] : x for x in res}.values())
+    
+    def get_random_subreddit_urls(self, num_urls:int = 20):
+        subr_l = list(itertools.product(subreddit_name_l, subreddit_sort_l, subreddit_t_l))
+        return [self.get_subreddit_url(*xs, 100) for xs in random.sample(subr_l, k=num_urls)]
+
+
+    def get_random_subreddit_query_urls(self, num_urls:int = 20, query_type: str = "chronology"):
+        '''
+            query_type:
+                chronology
+                random_word
+                random_phrase
+        '''
+        timeline = random.choices(["days", "months", "years"], k = num_urls)
+        timevalue = random.choices(range(1, 12), k = num_urls)
+        subr = random.sample(subreddit_name_l, k = num_urls)
+        
+        if query_type == "chronology":
+            return [self.get_subreddit_url(subreddit=sr, query=f"{tv} {tl} ago") for (sr, tl, tv) in list(itertools.product(subr, timeline, timevalue))]
+        elif query_type == "random_word":
+            r = RandomWords()
+            return [self.get_subreddit_url(subreddit=sr, query=f"{r.get_random_word()}") for sr in subr]
+        elif query_type == "random_phrase":
+            s = RandomSentence()
+            return [self.get_subreddit_url(subreddit=sr, query=f"{s.sentence()}") for sr in subr]
+        else:
+            return [ ]
+        
+        
+    def __call__(self, reddit_out_file: os.PathLike) -> Any:
+        dfname = reddit_out_file
+        otime = 0
+
+        tarr = []
+        karr = []
+
+        total_updates = 0
+
+        with tqdm(total=10000) as pbar:
+            for _  in range(10000):
+                if random.random() > 0.6:
+                    res = self.fetch_multiple_subreddit_image_entries(self.get_random_subreddit_urls(num_urls=100))
+                else:
+                    res = self.fetch_multiple_subreddit_image_entries(
+                        self.get_random_subreddit_query_urls(num_urls=5, query_type="random_phrase"))
+                
+                num_fetched = len(res)
+                
+                if res:
+                    if not Path(dfname).exists():
+                        pd.DataFrame(res).to_csv(dfname, index=False)
+                        karr.append(len(res))
+                    else:
+                        df = pd.read_csv(dfname)
+                        keys = set(df["image_id"])
+                        cres = [x for x in res if not (x["image_id"] in keys)]
+                        
+                        if cres:
+                            ndf = pd.DataFrame(cres)
+                            ndf.to_csv(dfname, mode="a", header=None, index=False)
+                        karr.append(len(cres))
+                else:
+                    karr.append(0)
+                        
+                ntime = pbar.format_dict['elapsed']
+                N = len(pd.read_csv(dfname))
+                tarr.append(ntime-otime)
+                otime = ntime
+                tarr = tarr[-25:]
+                karr = karr[-25:]
+                rate = sum(karr)/sum(tarr)
+                pbar.update(1)
+                total_updates = total_updates + karr[-1]
+                pbar.set_description_str(f"count:{N}, fetch rate:{rate:.3f}, last_update:{karr[-1]}, total_updates:{total_updates}")

reddit/redditd.py

@@ -0,0 +1,142 @@
+import argparse
+import os
+import random
+import glob
+from os import path as osp
+from typing import Optional
+from .core import WallpaperDownloader
+
+import pandas as pd
+
+from pathlib import Path
+from types import SimpleNamespace
+
+
+
+def save_as_dataframe(preferences_file, subreddit_name, parent_dir) -> None:
+    """
+    Saves the preferences as dataframe
+    """
+
+    parent_dir = Path(parent_dir)
+    reddit_df_path = parent_dir/"reddit.csv"
+
+    original_len = 0
+
+    try:
+        df = pd.read_json(preferences_file, 
+                parse_dates=False)
+        rdf = df.urls.apply(pd.Series)
+        ndf = df.join(rdf)
+        ndf = ndf.drop(columns=["urls"]).reset_index()
+        ndf["subreddit"] = subreddit_name
+        ndf["downloaded"] = False
+    except:
+        return
+
+    try:
+        if reddit_df_path.exists():
+            tdf = pd.read_csv(reddit_df_path)
+            original_len = len(tdf)
+            tdf = pd.concat([tdf, ndf], axis=0).drop_duplicates(subset=['index'])
+        else:
+            tdf = ndf
+    except (FileNotFoundError, pd.errors.EmptyDataError) as err:
+        tdf = ndf
+
+    new_len = len(tdf)
+    if new_len != original_len:
+        tdf.to_csv(reddit_df_path, index=False)
+
+
+def rdownloader(d : Optional[SimpleNamespace] = None):
+    """
+    Runs the main code. Downloads images, set and switches wallpapers.
+    """
+
+    if d is None:
+        # Process user inputs.
+        args = parse_args()
+    else:
+        args = d
+
+    parent_dir = Path(args.save_dir).expanduser()
+    save_dir = parent_dir.expanduser() / args.subreddit
+    save_dir.mkdir(parents=True, exist_ok=True)    
+    save_dir = str(save_dir)
+
+    # Setup the downloader.
+    downloader = WallpaperDownloader(subreddit=args.subreddit,
+                                     sort_time=args.sort_time,
+                                     sort_by=args.sort_by,
+                                     save_dir=save_dir)
+
+    # Download and return the total number of downloads.
+    total_downloaded = downloader.download(max_count=args.max_download_count)
+    save_as_dataframe(downloader._preferences_file, args.subreddit, parent_dir)
+
+    #print('Downloaded {} images from /r/{} sorted by {} for sort time {}'.format(total_downloaded,
+    #                                                                             args.subreddit,
+    #                                                                             args.sort_by,
+    #                                                                             args.sort_time))
+
+    if args.download_only:
+        return args.subreddit, total_downloaded
+
+    # Now setup wallpaper randomly from the wallpaper folder.
+    preferences = downloader.preferences
+    wallpapers = glob.glob(osp.join(preferences['wallpaper_dir'], '*.jpg'))
+    random.shuffle(wallpapers)
+
+    total_iters = int((args.run_for * 60) / args.update_every)
+
+    assert total_iters >= 1, "See help for run_for and update_every"
+
+    if total_iters >= len(wallpapers):
+        to_extend = int(total_iters/len(wallpapers)) + 1
+        wallpapers_copy = []
+        for _ in range(to_extend):
+            wallpapers_copy.extend(wallpapers.copy())
+        wallpapers = wallpapers_copy
+
+    for i in range(total_iters):
+        if preferences['os_type'] == 'Linux':
+            filepath = "gsettings set org.gnome.desktop.background picture-uri file:" + wallpapers[i]
+        elif preferences['os_type'] == 'Darwin':
+            filepath = "osascript -e 'tell application \"Finder\" to set desktop picture to POSIX file \"" + \
+                       wallpapers[i] + "\"'"
+        else:
+            raise NotImplementedError('Implemented only for Linux and Mac. ')
+
+        os.system(filepath)
+
+
+def parse_args():
+    """
+    Fetch user inputs from command line.
+    """
+    parser = argparse.ArgumentParser(
+        description='Download images and set wallpaper from your choice of subreddit!')
+    parser.add_argument('--subreddit', type=str, default='wallpaper',
+                        help='Your choice of subreddit to download Images. Default is "wallpaper".')
+    parser.add_argument('--sort_by', type=str, default='hot',
+                        help='Select sort-by option. Default is "hot". Options: hot|new|rising|top')
+    parser.add_argument('--sort_time', type=str, default='day',
+                        help='Sort time for subreddit. Default is "day". Options: all|year|month|week|day')
+    parser.add_argument('--max_download_count', type=int, default=20,
+                        help='Maximum number of images to download. Default is 20.')
+    parser.add_argument('--save_dir', type=str, default='~/me/data/reddit',
+                        help='Where to save downloaded images? '
+                             'By default it saves at machine default wallpapers folder')
+    parser.add_argument('--download_only', action='store_true', default=False,
+                        help='Only download the photos. Skip setting up wallpaper.')
+    parser.add_argument('--update_every', type=int, default=30,
+                        help='Update the wallpaper after how many mins? Default is 30 mins.')
+    parser.add_argument('--run_for', type=int, default=24,
+                        help='How long you want to keep updating the wallpaper? Default ius 24 hours.')
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == '__main__':
+    rdownloader()

reddit/subreddits.py

@@ -0,0 +1,194 @@
+SUBREDDITS = list(dict.fromkeys([
+    'BollywoodUHQonly',
+    
+    'Wallpapers',
+    'wallpaper',
+
+    'CityPorn', 
+    'VillagePorn', 
+    'RuralPorn', 
+    'ArchitecturePorn', 
+    'HousePorn', 
+    'CabinPorn', 
+    'ChurchPorn', 
+    'AbandonedPorn', 
+    'CemeteryPorn', 
+    'InfrastructurePorn', 
+    'MachinePorn', 
+    'carporn', 
+    'F1Porn', 
+    'MotorcyclePorn', 
+    'MilitaryPorn', 
+    'GunPorn', 
+    'KnifePorn', 
+    'BoatPorn', 
+    'RidesPorn', 
+    'DestructionPorn', 
+    'ThingsCutInHalfPorn', 
+    'StarshipPorn', 
+    'ToolPorn', 
+    'TechnologyPorn', 
+    'BridgePorn', 
+    'PolicePorn', 
+    'SteamPorn', 
+    'RetailPorn', 
+    'SpaceFlightPorn', 
+    'roadporn', 
+    'drydockporn',
+    'AnimalPorn', 
+    'HumanPorn', 
+    'EarthlingPorn', 
+    'AdrenalinePorn', 
+    'ClimbingPorn', 
+    'SportsPorn', 
+    'AgriculturePorn', 
+    'TeaPorn', 
+    'BonsaiPorn', 
+    'FoodPorn', 
+    'CulinaryPorn', 
+    'DessertPorn',
+    'DesignPorn', 
+    'RoomPorn', 
+    'AlbumArtPorn', 
+    'MetalPorn',
+    'MoviePosterPorn', 
+    'TelevisionPosterPorn', 
+    'ComicBookPorn', 
+    'StreetArtPorn', 
+    'AdPorn', 
+    'ArtPorn', 
+    'FractalPorn', 
+    'InstrumentPorn', 
+    'ExposurePorn', 
+    'MacroPorn', 
+    'MicroPorn', 
+    'GeekPorn', 
+    'MTGPorn', 
+    'GamerPorn', 
+    'PowerWashingPorn', 
+    'AerialPorn', 
+    'OrganizationPorn', 
+    'FashionPorn', 
+    'AVPorn', 
+    'ApocalypsePorn', 
+    'InfraredPorn', 
+    'ViewPorn', 
+    'HellscapePorn', 
+    'sculptureporn',
+
+    'HighResPrints',
+    'SpaceWallpapers',
+    
+    'ArtefactPorn',
+    'MegalithPorn',
+    'FossilPorn',
+    'FuturePorn',
+    'QuotesPorn',
+    'NewsPorn',
+    'BookPorn',
+    'UniformPorn',
+    'HistoryPorn',   
+    'AutumnPorn',
+    'EarthPorn',
+    'SkyPorn',
+    'SeaPorn',
+    'WeatherPorn',
+    'BotanicalPorn',
+    'LakePorn',
+    'BeachPorn',
+    'WaterPorn',
+    'SpacePorn',
+    'FirePorn',
+    'DesertPorn',
+    'WinterPorn',
+    'GeologyPorn',
+    'MushroomPorn',
+    'SpringPorn',
+    'SummerPorn',
+    'LavaPorn',
+    'multiwall',
+    'offensive_wallpapers',
+    'HI_Res',
+    'Forest',
+    'ArtFundamentals',
+    'Art',
+    'HighResCelebs',
+    'CelebEvents',
+    'UltraHighResCelebs',
+    'UHQcelebs',
+    'celebrityboners',
+    'HRCelebs',
+    'UHQDesi',
+    '4kcelebs',
+    'UltraHighResBollywood',
+    'Astronomy',
+    'MakeupAddiction',
+    'ultrahdwallpapers',
+    'FlowerPorn',
+    'mountainporn',
+    'RiverPorn',
+    'F1Porn',
+    'jameswebb',
+    'randomsexiness',
+    'gentlemanboners',
+    'BeautifulFemales',
+    'RoyalWarReport',
+    'DesiPetiteCelebs',
+    'travelphotos',
+    'IncredibleIndia',
+    'interestingasfuck',
+    'MuseumPorn',
+    'Fruitgore',
+    'FestivalSluts',
+    'festivals',
+    'AlternateAngles',
+    'ColorizedHistory',
+    'MoviemaniaHQ',
+    'IndianFoodPhotos',
+
+    'surrealism',
+
+    'Comics',
+    'SpecArt',
+    
+    'WTF',
+
+    'OldSchoolCool',
+
+    'pics',
+    'wwiipics',
+    'travelpics',
+
+    'photography',
+    'fashionphotography',
+    'productphotography',
+    'travelphotography',
+
+    'photocritique',
+    'itookapicture',
+    'PictureChallenge',
+    'photoit',
+    'postprocessing',
+
+
+    'outside',
+
+    'TheWayWeWere',
+
+    'Cinemagraphs',
+
+    'BlackPeopleTwitter',
+
+    'WtSSTaDaMiT',
+
+    'Eyebleach',
+
+    'me_irl',
+
+    'Posters',
+    'PropagandaPosters',
+    'PlexPosters',
+
+    'painting',
+]))
+

reddit/utils.py

@@ -0,0 +1,92 @@
+import json
+import os
+import platform
+import pwd
+import time
+from typing import List, Dict
+from os import path as osp
+
+import urllib.request as urllib2  # For Python 3.x
+
+class Utils:
+    """
+    Bunch of utils used for the Reddit Downloader.
+    """
+
+    @staticmethod
+    def save_to_preferences(preferences: Dict[str, Dict], preferences_file: str):
+        """
+        Save the preferences to a JSON file.
+        :param preferences: Dict containing preferences to save to file.
+        :param preferences_file: Location of the file where you want to save.
+        """
+        with open(preferences_file, 'w') as f:
+            json.dump(preferences, f)
+
+    @staticmethod
+    def load_preferences(preferences_file: str) -> Dict:
+        """
+        Load the preferences from JSON file and return as Dict.
+        :param preferences_file: Location of the file containing the preferences.
+        :return: preferences - Dict containing preferences to save to file.
+        """
+        with open(preferences_file, 'r') as f:
+            preferences = json.load(f)
+
+        return preferences
+
+    @staticmethod
+    def get_os():
+        """
+        Get the OS type (Linux or Macbook), and set the wallpaper folder accordingly.
+        :return:
+            os_type: Type of OS (Linux for Linux, Darwin for Mac).
+            wallpapers_directory: Directory where the wallpapers will be saved.
+        """
+        os_type = platform.system()
+        assert os_type in {'Darwin', 'Linux'}
+
+        # Get the username
+        username = pwd.getpwuid(os.getuid()).pw_name
+
+        # Set the directory to download images.
+        wallpapers_directory = '/Users/{}/Pictures/Wallpapers/'.format(username) if os_type == 'Darwin' \
+            else '/home/{}/Wallpapers/'.format(username)
+
+        return platform.system(), wallpapers_directory
+
+    @staticmethod
+    def remove_unwanted_images(images: List[str]):
+        """
+        Remove unwanted images. Since this is a naive approach, we might end up downloading some unwanted images, so we
+        delete them.
+        :param images: List of image file locations to filter and remove unwanted images from.
+        """
+        count_removed = 0
+        for image in images:
+            # These are some random html pages that might have been downloaded.
+            # This is a fairly quick and naive approach to downloading images from reddit.
+            if osp.getsize(image) < 102400:
+                os.remove(image)
+                count_removed += 1
+        return count_removed
+
+    @staticmethod
+    def fetch_subreddit_data(subreddit_url: str, max_trials: int = 20) -> Dict:
+        """
+        Fetch the subreddit JSON page based on the URL.
+        :param subreddit_url: URL created based on user inputs (subreddit, sort_type, sort_time, max_download_count).
+        :param max_trials: Maximum number of trial to use for fetching the subreddit JSON data.
+        :return: subreddit_data - Nested Dict containing Subreddit data for query.
+        """
+
+        subreddit_data = None
+        for _ in range(max_trials):
+            try:
+                subreddit_page = urllib2.urlopen(subreddit_url)
+                subreddit_data = json.load(subreddit_page)
+                break
+            except:
+                time.sleep(0.2)  # If we cannot access the reddit page, we wait for 2 seconds and retry.
+
+        return subreddit_data

requirements.txt

@@ -0,0 +1 @@
+rich

run_reddit.old.py

@@ -0,0 +1,146 @@
+#%%
+from pathlib import Path
+from pyparsing import Any
+from types import SimpleNamespace
+
+import time
+import random
+import filetype
+import numpy as np
+
+from rich.live import Live
+from rich.table import Table
+
+from reddit import rdownloader, SUBREDDITS
+
+class UCB:
+    def __init__(self, K) -> None:
+        self.K = K
+        self.xs = np.zeros(self.K)
+        self.Ts = np.zeros(self.K)
+        self.delta = 1./self.K
+        self.ucb = np.empty(self.K)
+        self.ucb.fill(10000.)
+
+    def update(self, idx, reward):
+        self.xs[idx] += reward
+        self.Ts[idx] += 1
+        self.ucb[idx] = (self.xs[idx]/self.Ts[idx]) + 2*np.sqrt(1./self.delta*(self.Ts[idx]))
+
+    def get_index(self):
+        return np.argmax(self.ucb)
+
+
+class RedditDownloader:
+    def initialize_subreddit_counter(self):
+        for subreddit in SUBREDDITS:
+            subreddit_folder = self.reddit_root_dir / subreddit
+
+            imfiles = [imfile for imfile in subreddit_folder.glob('*') if filetype.is_image(imfile)]
+
+            self.subreddit_counter[subreddit] = len(imfiles)
+            #self.delay_counter[subreddit] = 0
+            self.changed_status[subreddit] = False
+
+    def __init__(self) -> None:
+        self.reddit_root_dir = Path("~/me/data/reddit").expanduser()
+        self.subreddit_counter = { }
+        self.changed_status = {}
+
+        self.initialize_subreddit_counter()
+        
+    def generate_table(self, overall_run_status = True, subreddit = None, running = False) -> Table:
+        """Make a new table."""
+        table = Table()
+
+        overall_run_status_col = "green" if overall_run_status else "yellow"
+
+        table.add_column(f"[{overall_run_status_col}]Subreddit")
+        table.add_column("Total Images")
+
+        total = 0
+
+        for subr, kount in self.subreddit_counter.items():
+            changed_num_col= "orchid" if self.changed_status[subr] else "blue"
+
+            if subr != subreddit:
+                table.add_row(f"{subr}", f"[{changed_num_col}]{kount}")
+            else:
+                if running == False:
+                    table.add_row(f"[magenta3]{subr}", f"[{changed_num_col}]{kount}")
+                else:
+                    table.add_row(f"[green]{subr}", f"[{changed_num_col}]{kount}")
+            total += kount
+
+        table.add_section()
+        table.add_row(f"[silver]Total", f"[blue]{total}")
+
+        return table
+
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+
+        run_list = set(SUBREDDITS)
+
+        delays = 0
+
+        with Live(self.generate_table(overall_run_status=True), auto_refresh=False, refresh_per_second=0.01) as live:
+
+            while True:
+                
+                chosen_sort_by = random.choice(['new', 'hot', 'top', 'rising'])
+                chosen_sort_time = random.choice(['day', 'week', 'month', 'year', 'all'])
+
+                for subreddit in SUBREDDITS:
+                    self.changed_status[subreddit] = False
+
+                for subreddit in SUBREDDITS:
+
+                    if subreddit not in run_list: continue
+
+                    overall_run_status = len(run_list) > 0
+
+                    live.update(self.generate_table(overall_run_status, subreddit, running=True), refresh=True)
+                    d = { }
+                    d["subreddit"] = subreddit
+                    d["sort_by"] = chosen_sort_by
+                    d["sort_time"] = chosen_sort_time
+                    d["max_download_count"] = 200
+                    d["save_dir"] = self.reddit_root_dir
+                    d["download_only"] = True
+                    d["update_every"] = 20
+                    d["run_for"] = 24
+                    d = SimpleNamespace(**d)
+                    rsubreddit, total_downloaded = rdownloader(d)
+                    
+                    if subreddit in self.subreddit_counter:
+                        self.subreddit_counter[subreddit] += total_downloaded
+                    else:
+                        self.subreddit_counter[subreddit] = total_downloaded
+                    
+                    if total_downloaded == 0:
+                        run_list.remove(subreddit)
+
+                    self.changed_status[subreddit] = (total_downloaded > 0)
+
+                    overall_run_status = len(run_list) > 0
+
+                    live.update(self.generate_table(overall_run_status, subreddit, running=False), refresh=True)
+
+                if len(run_list) == 0:
+                    time.sleep(120)
+                    delays = 0
+                    run_list = set(SUBREDDITS)
+                else:
+                    delays += 30
+                    time.sleep(30)
+                    if (delays > 120):
+                        run_list = set(SUBREDDITS)
+                    if run_list == set(SUBREDDITS):
+                        delays = 0
+
+
+if __name__ == "__main__":
+    RedditDownloader()()
+
+# %%