notebooks/create-medium-story-automated.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Automate Medium Story Creation with Python\n",
    "In this tutorial, we will learn how to automate the process of creating a Medium story using the Medium API. This will allow you to programmatically publish stories on your Medium account.\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is an overview of the steps we will take to create a story using the Medium API in Python:\n",
    "1. [Prerequisites](#1-prerequisites)\n",
    "2. [Function to do API call](#2-function-to-do-api-call)\n",
    "3. [Function to create a story](#3-function-to-create-a-story)\n",
    "4. [Create a story](#4-create-a-story)\n",
    "5. [Optional: Create a Story from a Jupyter Notebook](#5-optional-create-a-story-from-a-jupyter-notebook)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Prerequisites"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use the Medium API, you need to follow these steps to generate the token:\n",
    "1. Go to \"Settings\" Page by clicking on your profile picture at the top right corner of the medium home page.\n",
    "2. Under \"Security and apps\" tab, click on \"Integration tokens\" at the bottom of the page.\n",
    "3. Generate a new token by clicking on \"Get token\" button.\n",
    "4. Create a new file named `.env` in the root directory of this project and paste the token in it as follows:\n",
    "    ```\n",
    "    MEDIUM_TOKEN=\"<Your_Token>\"\n",
    "    ```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Load Environment Variables "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's load the environment variables from the `.env` file. This step is essential for authenticating our API calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "load_dotenv()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Function to do API call"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To interact with the Medium API, we need to create a function that can send HTTP requests to the API endpoints. We'll use the `requests` library to achieve this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "from typing import Optional, Dict, Any, List\n",
    "\n",
    "\n",
    "def send_request(\n",
    "    url: str,\n",
    "    method: str = \"get\",\n",
    "    body: Optional[Dict[str, Any]] = None,\n",
    "    headers: Optional[Dict[str, Any]] = None,\n",
    ") -> Dict[str, Any]:\n",
    "    \"\"\"\n",
    "    Send a request to the Medium API\n",
    "\n",
    "    :param url: The URL to send the request to\n",
    "    :param method: The HTTP method to use\n",
    "    :param body: The body of the request\n",
    "    :param headers: The headers of the request\n",
    "    :return: The response of the request\n",
    "    \"\"\"\n",
    "    response = requests.request(method, url, json=body, headers=headers)\n",
    "    return response.json()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Function to Create a Story"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll create a function that allows us to create a new Medium story using the authenticated user's account. Before calling this function, ensure you have set the `MEDIUM_TOKEN` environment variable from the prerequisites step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_id = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_post(\n",
    "    title: str,\n",
    "    content: str,\n",
    "    content_format: str = \"markdown\",\n",
    "    tags: Optional[List[str]] = None,\n",
    "    canonical_url: Optional[str] = None,\n",
    "    publish_status: str = \"draft\",\n",
    ") -> Dict[str, Any]:\n",
    "    \"\"\"\n",
    "    Create a post on Medium.\n",
    "\n",
    "    :param title: The title of the post, used for SEO, doesn't appear in the actual post.\n",
    "    Should be less than 100 characters.\n",
    "    :param content: The content of the post.\n",
    "    :param content_format: The format of the content, either `html` or `markdown`, defaults to `markdown`.\n",
    "    :param tags: The tags of the post, used to classify the post. Only the first three will be used.\n",
    "    Should be less than 25 characters each. Defaults to `None`.\n",
    "    :param canonical_url: The original url of this content, if it was originally published elsewhere.\n",
    "    Defaults to `None`.\n",
    "    :param publish_status: The publish status of the post, either `public`, `draft`, or `unlisted`,\n",
    "    defaults to `draft`.\n",
    "    :return: The response of the request.\n",
    "    \"\"\"\n",
    "    global user_id\n",
    "\n",
    "    # Get the user_id\n",
    "    if user_id is None:\n",
    "        my_details_url = \"https://api.medium.com/v1/me\"\n",
    "        headers = {\"Authorization\": f\"Bearer {os.environ.get('MEDIUM_TOKEN')}\"}\n",
    "\n",
    "        response = send_request(my_details_url, headers=headers)\n",
    "        user_id = response.get(\"data\").get(\"id\")\n",
    "\n",
    "    # Ready to create a post\n",
    "    url = f\"https://api.medium.com/v1/users/{user_id}/posts\"\n",
    "\n",
    "    # set headers\n",
    "    headers = {\"Authorization\": f\"Bearer {os.environ.get('MEDIUM_TOKEN')}\"}\n",
    "\n",
    "    # set body\n",
    "    body = {\n",
    "        \"title\": title,\n",
    "        \"contentFormat\": content_format,\n",
    "        \"content\": content,\n",
    "        \"tags\": tags,\n",
    "        \"canonicalUrl\": canonical_url,\n",
    "        \"publishStatus\": publish_status,\n",
    "    }\n",
    "\n",
    "    # send request with body and authentication bearer token\n",
    "    response = send_request(url, method=\"post\", body=body, headers=headers)\n",
    "    return response"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Create a Story"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's create a new Medium story using the `create_post` function. Modify the variables as per your need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = \"1st Test Post\"\n",
    "content = \"# Heading! \\n## Sub-Heading! \\n Welcome to my first post!\"\n",
    "content_format = \"markdown\"\n",
    "tags = [\"test\", \"python\", \"medium\"]\n",
    "canonical_url = \"https://medium.com/@xyz\"\n",
    "publish_status = \"draft\"\n",
    "\n",
    "response = create_post(\n",
    "    title, content, content_format, tags, canonical_url, publish_status\n",
    ")\n",
    "response"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Optional: Create a Story from a Jupyter Notebook"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 Function to Convert Notebook to Markdown"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function allows you to convert a Jupyter Notebook to Markdown."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import nbformat\n",
    "from nbconvert import MarkdownExporter\n",
    "\n",
    "\n",
    "def notebook_url_to_markdown(url: str) -> str:\n",
    "    \"\"\"\n",
    "    Convert a Jupyter Notebook to Markdown.\n",
    "\n",
    "    :param url: The URL of the Jupyter Notebook.\n",
    "    :return: The Markdown content of the Jupyter Notebook.\n",
    "    \"\"\"\n",
    "    # Fetch the Jupyter Notebook from the URL\n",
    "    response = requests.get(url)\n",
    "    notebook_content = response.text\n",
    "\n",
    "    # Parse the notebook using nbformat\n",
    "    notebook = nbformat.reads(notebook_content, as_version=nbformat.NO_CONVERT)\n",
    "    metadata = notebook.get(\"metadata\", {})\n",
    "\n",
    "    # Convert the notebook to Markdown\n",
    "    md_exporter = MarkdownExporter()\n",
    "    markdown, _ = md_exporter.from_notebook_node(notebook, resources=metadata)\n",
    "\n",
    "    return markdown"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Note: Please copy the **raw url** of the notebook from GitHub.\n",
    "\n",
    "Modify the variables as per your need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# url from github must be raw url\n",
    "notebook_url = \"https://raw.githubusercontent.com/iamrk04/TaskAutomationKit/main/notebooks/create-medium-story-automated.ipynb\"\n",
    "markdown_content = notebook_url_to_markdown(notebook_url)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 Create a Story from Markdown"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify the variables as per your need."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "title = \"Automate Medium Story Creation with Python\"\n",
    "content = markdown_content\n",
    "content_format = \"markdown\"\n",
    "tags = [\"python\", \"medium\", \"automation\"]\n",
    "canonical_url = \"https://github.com/iamrk04/TaskAutomationKit/blob/main/notebooks/create-medium-story-automated.ipynb\"\n",
    "publish_status = \"draft\"\n",
    "\n",
    "response = create_post(\n",
    "    title, content, content_format, tags, canonical_url, publish_status\n",
    ")\n",
    "response"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}