British_Styled_Crosswords_Scrapper.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNC0jVecCD41O7ydgZXGnAJ",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kaledai069/Crossword-Generator/blob/master/British_Styled_Crosswords_Scrapper.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q git+https://github.com/alexdej/puzpy.git\n",
        "!pip install -q xword-dl"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l0EKnTHQL2nK",
        "outputId": "52455c01-dcb2-4584-9319-6a1cb1b5834a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m143.0/143.0 kB\u001b[0m \u001b[31m4.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m293.8/293.8 kB\u001b[0m \u001b[31m6.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m235.9/235.9 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m7.1/7.1 MB\u001b[0m \u001b[31m19.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import datetime\n",
        "import subprocess\n",
        "import puz\n",
        "import glob\n",
        "import os\n",
        "import json\n",
        "\n",
        "from math import floor, ceil\n",
        "from PIL import Image, ImageDraw, ImageFont"
      ],
      "metadata": {
        "id": "K47dQ7qhL5lj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### British-Style Crossword Grid Generator"
      ],
      "metadata": {
        "id": "bjiYrhNFKWEl"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "T7bU86itGu1Z"
      },
      "outputs": [],
      "source": [
        "def generate_british_style(arr):\n",
        "    random_indices = [i * 2 for i in range(len(arr[0]) // 2)]\n",
        "\n",
        "    selected = random.sample(random_indices, len(random_indices) // 4)\n",
        "\n",
        "    selected2 = [index + 1 for index in selected]\n",
        "    random.shuffle(selected2)\n",
        "\n",
        "    for i in range(len(arr)):\n",
        "        if i % 2 == 0:\n",
        "            if i not in selected:\n",
        "                arr[i][random.randint(0, len(arr[i]) - 1)] = '*'\n",
        "        else:\n",
        "            for j in range(len(arr[i])):\n",
        "                if j % 2 == 1:\n",
        "                    arr[i][j] = '*'\n",
        "            if i in selected2:\n",
        "                s = random.randint(0, len(arr[i]) - 1)\n",
        "                if s % 2 == 1:\n",
        "                    s -= 1\n",
        "                arr[i][s] = '*'\n",
        "\n",
        "# Example usage:\n",
        "rows = 5\n",
        "columns = 5\n",
        "grid_size = 21\n",
        "grid = [[' ' for _ in range(grid_size)] for _ in range(grid_size)]\n",
        "generate_british_style(grid)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def visualize_crossword_image(grid, black_cell_str = '*', grid_nums = None, cell_size = 30, black_square_color=\"black\", text_color=\"black\", image_file=\"crossword.png\"):\n",
        "    \"\"\"\n",
        "    Create an image representation of the crossword grid.\n",
        "\n",
        "    Parameters:\n",
        "    - grid (list): The crossword grid.\n",
        "    - cell_size (int): Size of each cell in pixels.\n",
        "    - black_square_color (str): Color for black squares.\n",
        "    - text_color (str): Color for text.\n",
        "    - image_file (str): File name to save the image.\n",
        "\n",
        "    Returns:\n",
        "    - None\n",
        "    \"\"\"\n",
        "    height = len(grid) * cell_size + 1\n",
        "    width = len(grid[0]) * cell_size + 1\n",
        "\n",
        "    img = Image.new(\"RGB\", (width, height), \"white\")\n",
        "    draw = ImageDraw.Draw(img)\n",
        "\n",
        "    font = ImageFont.load_default()\n",
        "\n",
        "    # Adjust font size\n",
        "    font_size = 8  # Set your desired font size\n",
        "    font = ImageFont.truetype(\"./Roboto-Regular.ttf\", font_size)\n",
        "\n",
        "    for row in range(len(grid)):\n",
        "        for col in range(len(grid[row])):\n",
        "            x = col * cell_size\n",
        "            y = row * cell_size\n",
        "            rect = [(x, y), (x + cell_size, y + cell_size)]\n",
        "\n",
        "            if grid[row][col] == black_cell_str:\n",
        "                draw.rectangle(rect, fill = black_square_color)\n",
        "            else:\n",
        "                draw.rectangle(rect, outline = \"black\")\n",
        "                # if grid_nums[row][col] != 0:\n",
        "                #   draw.text((x + cell_size // 2 - 7, y + cell_size // 2 - 8), str(grid_nums[row][col]), fill=text_color, anchor=\"mm\", font=font)\n",
        "\n",
        "    img_array = np.array(img)\n",
        "    plt.figure(figsize = (6, 6))\n",
        "    plt.imshow(img_array)\n",
        "    plt.axis('off')\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "B4lmKfXFJ24L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "visualize_crossword_image(grid, '*')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "Xw6jes0qLVsn",
        "outputId": "e1a094ab-1bfa-4e9c-90c4-f9438e20e6f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def puz_to_json(fname):\n",
        "    \"\"\" Converts a puzzle in .puz format to .json format\n",
        "    \"\"\"\n",
        "    p = puz.read(fname)\n",
        "    numbering = p.clue_numbering()\n",
        "\n",
        "    grid = [[None for _ in range(p.width)] for _ in range(p.height)]\n",
        "    for row_idx in range(p.height):\n",
        "        cell = row_idx * p.width\n",
        "        row_solution = p.solution[cell:cell + p.width]\n",
        "        for col_index, item in enumerate(row_solution):\n",
        "            if p.solution[cell + col_index:cell + col_index + 1] == '.':\n",
        "                grid[row_idx][col_index] = 'BLACK'\n",
        "            else:\n",
        "                grid[row_idx][col_index] = [\"\", row_solution[col_index: col_index + 1]]\n",
        "\n",
        "    across_clues = {}\n",
        "    for clue in numbering.across:\n",
        "        answer = ''.join(p.solution[clue['cell'] + i] for i in range(clue['len']))\n",
        "        across_clues[str(clue['num'])] = [clue['clue'] + ' ', ' ' + answer]\n",
        "        grid[int(clue['cell'] / p.width)][clue['cell'] % p.width][0] = str(clue['num'])\n",
        "\n",
        "    down_clues = {}\n",
        "    for clue in numbering.down:\n",
        "        answer = ''.join(p.solution[clue['cell'] + i * numbering.width] for i in range(clue['len']))\n",
        "        down_clues[str(clue['num'])] = [clue['clue'] + ' ', ' ' + answer]\n",
        "        grid[int(clue['cell'] / p.width)][clue['cell'] % p.width][0] = str(clue['num'])\n",
        "\n",
        "\n",
        "    mydict = {'metadata': {'date': None, 'rows': p.height, 'cols': p.width}, 'clues': {'across': across_clues, 'down': down_clues}, 'grid': grid}\n",
        "    return mydict\n",
        "\n",
        "def download_crossword(publication, publication_keyword, start_date, end_date, output_dir):\n",
        "    if not os.path.exists(os.path.join(output_dir, publication)):\n",
        "        os.mkdir(os.path.join(output_dir, publication))\n",
        "\n",
        "    current_date = start_date\n",
        "\n",
        "    while current_date <= end_date:\n",
        "        formatted_date_str = current_date.strftime(\"%m/%d/%y\")\n",
        "        output_date_str = current_date.strftime(\"%m-%d-%Y\")\n",
        "\n",
        "        try:\n",
        "            output_file_path = f\"{output_dir}/{publication}/crossword_{output_date_str}.puz\"\n",
        "            command = f'xword-dl {publication_keyword} --date {formatted_date_str} -o {output_file_path}'\n",
        "            subprocess.run(command, shell = True, check = True, stdout = subprocess.PIPE, text = True)\n",
        "            print(f\"Successfully downloaded for {publication}: Filename - crossword_{output_date_str}.puz\")\n",
        "        except:\n",
        "            print(f\"Error in downloading crossword for: {output_date_str}\")\n",
        "\n",
        "        current_date += datetime.timedelta(days = 1)\n",
        "\n",
        "def convert_to_json(publication, puz_output_dir, json_output_dir):\n",
        "\n",
        "    all_puz_files = glob.glob(os.path.join(puz_output_dir, publication, '*.puz'))\n",
        "\n",
        "    if not os.path.exists(os.path.join(json_output_dir, publication)):\n",
        "        os.mkdir(os.path.join(json_output_dir, publication))\n",
        "\n",
        "    for puz_file_path in all_puz_files:\n",
        "        json_output_path = puz_file_path.replace('.puz', '.json').replace('puz', 'json')\n",
        "        json_data = puz_to_json(puz_file_path)\n",
        "        with open(json_output_path, 'w') as f:\n",
        "            json.dump(json_data, f)\n",
        "\n",
        "\n",
        "publication_keyword = \"sdpq\"\n",
        "publication = 'simply-daily-puzzles-quick'\n",
        "start_date = datetime.date(2023, 12, 1)\n",
        "end_date= datetime.date(2023, 12, 31)\n",
        "puz_output_dir = \"/content/puz\"\n",
        "json_output_dir = \"/content/json\"\n",
        "\n",
        "# just make the puz directory\n",
        "if not os.path.exists(puz_output_dir):\n",
        "    os.mkdir(puz_output_dir)\n",
        "\n",
        "# make publication specific directory\n",
        "if not os.path.exists(os.path.join(puz_output_dir, publication)):\n",
        "    os.mkdir(os.path.join(puz_output_dir, publication))\n",
        "\n",
        "\n",
        "download_crossword(publication, publication_keyword, start_date, end_date, puz_output_dir)\n",
        "# convert_to_json(publication, puz_output_dir, json_output_dir)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fkeOIrzlLZbF",
        "outputId": "b91ba9b5-e175-4765-9d9a-9234f2930724"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-01-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-02-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-03-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-04-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-05-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-06-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-07-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-08-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-09-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-10-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-11-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-12-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-13-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-14-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-15-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-16-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-17-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-18-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-19-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-20-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-21-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-22-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-23-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-24-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-25-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-26-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-27-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-28-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-29-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-30-2023.puz\n",
            "Successfully downloaded for simply-daily-puzzles-quick: Filename - crossword_12-31-2023.puz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "puz_files = glob.glob(os.path.join(puz_output_dir, publication, '*.puz'))\n",
        "selected = random.choice(puz_files)\n",
        "print(selected)\n",
        "json_grid_data = puz_to_json(selected)\n",
        "grid_array = json_grid_data['grid']\n",
        "rows, cols = json_grid_data['metadata']['rows'], json_grid_data['metadata']['cols']\n",
        "\n",
        "grid_structure = []\n",
        "for row in grid_array:\n",
        "    row_array = []\n",
        "    for col_element in row:\n",
        "        if isinstance(col_element, list):\n",
        "            row_array.append('')\n",
        "        else:\n",
        "            row_array.append('*') # using * for Black Cells\n",
        "\n",
        "    grid_structure.append(row_array)\n",
        "\n",
        "visualize_crossword_image(grid_structure, None)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "v3Q65l9nMayK",
        "outputId": "1bbaed52-5684-4fbe-f370-f15f88092008"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/content/puz/simply-daily-puzzles-quick/crossword_12-11-2023.puz\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "### lets try-out making some british-style grids from above examples\n",
        "grid_size = 13\n",
        "rows = cols = grid_size\n",
        "grid_array = [['W'] * cols for _ in range(rows)]\n",
        "\n",
        "for row in range(1, rows, 2): # odd_places\n",
        "    for col in range(1, cols, 2):\n",
        "        grid_array[row][col] = 'B'\n",
        "\n",
        "for i in range(0, ceil(rows / 2)): #even_places\n",
        "    random_indices = random.sample(range(0, cols), random.randint(1, 2))\n",
        "    for j in random_indices:\n",
        "        grid_array[i][j] = 'B'\n",
        "        grid_array[rows - 1 - i][cols - 1 - j] = 'B'\n",
        "\n",
        "visualize_crossword_image(grid_array, 'B')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 499
        },
        "id": "uOX6uB2GQYoN",
        "outputId": "f6372e32-7713-4779-ffd9-ee17a0683848"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random\n",
        "\n",
        "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zBpKLllkUxRy",
        "outputId": "e93e57dc-2007-44b9-af16-1c2ff83c61dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[20, 4]"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    }
  ]
}