DEV Community: Abhishek Choudhary

Keeping Your Streamlit App Awake with Serverless Functions and a Free Cron Job

Abhishek Choudhary — Thu, 22 Oct 2026 05:23:06 +0000

You deploy a little Streamlit app on Community Cloud, share the link, and a day later it's showing a sleepy "Zzzz, this app has gone to sleep due to inactivity" page. Anyone who opens it has to click a button and wait for a cold start.

There's no keep-alive switch in Streamlit Community Cloud, and the advice on the forums boils down to "push an empty commit" or "automate a browser". Both work, but both are heavier than they need to be. There's a simpler way: do exactly what that button does, with one HTTP request, on a schedule.

⚠️ This uses an undocumented endpoint that the Streamlit web page itself calls. It can change without notice. Only use it on apps you own, and keep the schedule gentle.

What the "wake up" button really does

If you open dev tools on a sleeping app and click Yes, get this app back up!, you'll see a single request:

POST https://<your-app>.streamlit.app/api/v2/app/resume

It needs two small things besides the POST itself, and neither one is a login:

A CSRF token. The page never stores it anywhere fancy. It simply remembers the x-csrf-token response header from the previous API call and sends it back. The server also sets a matching _streamlit_csrf cookie on that same response.
A machine id. A random UUID sent as x-streamlit-machine-id.

So the whole dance is: ask for the app status, grab the token and cookie, then POST to resume.

Try it with curl

I'm using webpie.streamlit.app here, swap in your own app URL. Save this as wake.sh:

#!/usr/bin/env bash
# Wake a sleeping Streamlit Community Cloud app.
# Usage: ./wake.sh https://webpie.streamlit.app
set -euo pipefail

APP_URL="${1:?usage: ./wake.sh https://webpie.streamlit.app}"
COOKIES="$(mktemp)"
trap 'rm -f "$COOKIES"' EXIT

# Step 1: any API call hands us a CSRF cookie (saved in the jar)
# and an x-csrf-token response header (we grab it here).
CSRF_TOKEN=$(
  curl --silent --output /dev/null --dump-header - \
    --cookie-jar "$COOKIES" \
    "$APP_URL/api/v2/app/status" \
  | tr -d '\r' \
  | awk -F': ' 'tolower($1) == "x-csrf-token" { print $2 }'
)

# Step 2: the browser also sends a random UUID as a machine id.
MACHINE_ID=$(uuidgen | tr '[:upper:]' '[:lower:]')

# Step 3: this is the call behind the "Yes, get this app back up!" button.
curl --silent --include --request POST \
  --cookie "$COOKIES" --cookie-jar "$COOKIES" \
  --header "x-csrf-token: $CSRF_TOKEN" \
  --header "x-streamlit-machine-id: $MACHINE_ID" \
  --header "origin: $APP_URL" \
  --header "referer: $APP_URL/" \
  "$APP_URL/api/v2/app/resume"
echo

# Step 4 (optional): check the status afterwards
curl --silent --cookie "$COOKIES" "$APP_URL/api/v2/app/status"
echo

Run it:

chmod +x wake.sh
./wake.sh https://webpie.streamlit.app

A 204 No Content from the resume call means the request was accepted. The status call at the end shows the app's state; while it's booting, the status number changes. (An app that's already awake just answers normally, so it's safe to run any time.)

Make it run itself

A shell script on your laptop doesn't help while you're asleep too. The nice part is that the logic is just fetch calls, so it runs on almost any serverless platform: Cloudflare Workers, Vercel, Netlify, AWS Lambda, Deno Deploy. Pick whichever you already use.

Here's the core logic once, in plain JavaScript:

// Shared logic: wake a Streamlit Community Cloud app.
// Works in Cloudflare Workers, Vercel, Netlify, Node 18+, anything with fetch.
export async function wakeApp(appUrl) {
  // Step 1: any API call gives us a CSRF cookie and an x-csrf-token header.
  const status = await fetch(`${appUrl}/api/v2/app/status`);
  const csrfToken = status.headers.get("x-csrf-token");
  const cookies = status.headers
    .getSetCookie()
    .map((cookie) => cookie.split(";")[0]) // keep "name=value", drop attributes
    .join("; ");

  // Step 2: this is the call behind the "Yes, get this app back up!" button.
  const resume = await fetch(`${appUrl}/api/v2/app/resume`, {
    method: "POST",
    headers: {
      cookie: cookies,
      "x-csrf-token": csrfToken,
      "x-streamlit-machine-id": crypto.randomUUID(),
      origin: appUrl,
      referer: `${appUrl}/`,
    },
  });

  return { ok: resume.ok, status: resume.status };
}

Option A: Cloudflare Workers

worker.js:

import { wakeApp } from "./wake.js";

export default {
  async fetch(request, env) {
    // Optional: stop strangers from poking your endpoint
    const secret = new URL(request.url).searchParams.get("key");
    if (env.WAKE_KEY && secret !== env.WAKE_KEY) {
      return new Response("Nope", { status: 401 });
    }

    const result = await wakeApp(env.APP_URL);
    return Response.json(result);
  },
};

Set APP_URL (for example https://webpie.streamlit.app) and an optional WAKE_KEY as variables in the Worker settings, then deploy with npx wrangler deploy. You'll get a URL like https://wake-streamlit.<you>.workers.dev/?key=<your key>.

Option B: Vercel

Put wake.js in your project root and add api/wake.js:

import { wakeApp } from "../wake.js";

export default async function handler(req, res) {
  if (process.env.WAKE_KEY && req.query.key !== process.env.WAKE_KEY) {
    return res.status(401).send("Nope");
  }

  const result = await wakeApp(process.env.APP_URL);
  res.status(200).json(result);
}

Add APP_URL and WAKE_KEY under Project Settings → Environment Variables and deploy. Your endpoint is https://<project>.vercel.app/api/wake?key=<your key>.

Trigger it with cron-job.org (free)

You don't even need the platform's own scheduler. cron-job.org is free and will call any URL on a schedule:

Create an account and click Create cronjob.
URL: the Worker or Vercel endpoint from above, including ?key=....
Schedule: every 6 hours is plenty. Apps seem to sleep after roughly 12 hours without visitors, so you want to land well inside that window.
Save. Under the job's history you can see each run's status code. 200 means your function ran.

That's the whole setup: cron-job.org pokes your serverless function, the function pokes Streamlit, and your app stays warm. No browser, no Selenium, no fake commits.

Things worth knowing

It's unofficial. If Streamlit changes the endpoint, the script breaks. Check the cron history now and then.
It's polite use only. One request every few hours for your own app. Please don't hammer it.
Waking isn't the same as being busy. This resumes a sleeping app. It doesn't pretend to be traffic, so the app can still go back to sleep later, which is why the schedule keeps repeating.
Keep the key secret so nobody else can trigger your function.

If you'd rather stay inside the official lines, the alternative is hosting the app somewhere that doesn't sleep. But for a free-tier hobby app, a 20-line function and a free cron service is hard to beat.

Happy hacking!

Building a Physics-Accurate Live Wallpaper for Android

Abhishek Choudhary — Thu, 30 Jul 2026 09:28:54 +0000

A while back I built a double-pendulum simulation in the browser. The motion is hard to stop watching. Two bobs, one hinge, and the trajectory never repeats. I kept thinking it would make a good live wallpaper, so I eventually ported it to Android.

This is the story of how that port went.

Starting point: the web simulation

The browser version runs entirely in a <canvas> element. Physics are integrated with RK4 over the Hamiltonian equations of motion, and the path tracer stores a circular buffer of past positions. The coordinate system is a normalised viewBox so it scales cleanly to any window size.

The goal for the Android version was pixel-identical output: same stroke widths, same bob radii, same trace behavior, same graph. Not a visual approximation.

WallpaperService and the rendering surface

Android live wallpapers subclass WallpaperService and expose a Surface through the Engine callbacks. The canonical pattern is to acquire a Canvas from the surface, draw into it, and post it back:

val canvas = surfaceHolder.lockCanvas() ?: return
try {
    draw(canvas)
} finally {
    surfaceHolder.unlockCanvasAndPost(canvas)
}

The tricky part is the coordinate system. The surface dimensions are in physical pixels and vary across devices. To get pixel-identical output I mirrored the web approach exactly: define everything in a normalised viewBox of 100 x (100 * H/W) units, then scale the canvas once at the start of each frame:

canvas.scale(width / 100f, width / 100f)

Stroke widths, bob radii, and the graph are all specified in viewBox units. The single scale transform handles the rest.

Physics: Hamiltonian + RK4

The double pendulum is not easily simulated with naive Euler integration because energy drifts quickly. The web version uses the Hamiltonian formulation, where generalised momenta are tracked alongside the angles, and RK4 advances the state each tick.

Translating this from JavaScript to Kotlin was mostly mechanical. The main difference is that Kotlin does not have let destructuring the same way, so the intermediate RK4 derivatives end up as explicit DoubleArray copies:

fun rk4Step(state: DoubleArray, dt: Double): DoubleArray {
    val k1 = derivatives(state)
    val k2 = derivatives(state.addScaled(k1, dt / 2))
    val k3 = derivatives(state.addScaled(k2, dt / 2))
    val k4 = derivatives(state.addScaled(k3, dt))
    return DoubleArray(state.size) { i ->
        state[i] + dt / 6.0 * (k1[i] + 2*k2[i] + 2*k3[i] + k4[i])
    }
}

The simulation runs at whatever frame rate the surface provides and scales the timestep accordingly, so speed on fast and slow devices stays consistent.

Keeping settings consistent across three contexts

One of the more interesting design problems was state management. There are three distinct contexts that each need a different view of the settings:

In-app preview while the user is tweaking parameters
The live wallpaper surface running on the home screen
Saved presets the user wants to recall later

If the settings activity wrote directly to the shared prefs that the wallpaper service reads, every slider drag would immediately change the live wallpaper. That felt wrong.

The solution was three separate SharedPreferences stores:

chaotic_session: written freely during the settings session, cleared on every app launch so it never bleeds into the wallpaper
chaotic_wallpaper: read by the WallpaperService; written only when the user taps SET AS WALLPAPER
chaotic_persistent: stores named presets, survives the session

This way the user can drag bobs, shuffle with RANDOM, adjust mass and speed, and watch the in-app preview update in real time. None of that touches the live wallpaper until they explicitly commit.

Drag-to-customize while paused

The in-app preview lets you drag the bobs to set the initial position. Hit detection maps the touch coordinates back through the inverse of the viewBox scale and checks distance against each bob's radius. When a bob is being dragged, the physics step is skipped and the state is overwritten with the new angles derived from the touch position.

One edge case: if both bobs are near each other, you want the touch to grab the nearer one. A simple nearest-first sort on touch-distance handles it.

OLED and battery

The wallpaper uses a pure black background (0xFF000000), which means OLED pixels in the black regions are literally off. This is intentional.

For battery, the WallpaperService.Engine provides onVisibilityChanged. When the wallpaper is not visible (another app is in the foreground, screen is off), the rendering loop stops:

override fun onVisibilityChanged(visible: Boolean) {
    if (visible) startRendering() else stopRendering()
}

The app also has zero permissions beyond BIND_WALLPAPER and makes no network requests.

Build setup

The project uses AGP 8.7.3 with R8 minification and resource shrinking in release. Release signing goes through a gitignored keystore.properties file; if the file is absent the build falls back to the debug key automatically so CI and forks can still build.

./gradlew :app:bundleRelease   # AAB for Play Store
./gradlew :app:assembleRelease # APK for sideloading

Result

The final app is a faithful port of the web simulation, running as a live wallpaper. The physics are identical, the visuals are pixel-matched across screen sizes, and the settings model keeps the preview experience independent from the live wallpaper until you decide to commit.

It is free, has no ads, and collects no data.

Canvas API

Abhishek Choudhary — Thu, 21 Mar 2024 03:09:14 +0000

This is a submission for DEV Challenge v24.03.20, One Byte Explainer: Browser API or Feature.

Explainer

The Canvas API provides a drawing surface for creating visually engaging graphics and images using JavaScript to dynamically render shapes, paths, text, and images, enabling the creation of interactive charts, animations, and games on the web.

Serialize and Deserialize BST

Abhishek Choudhary — Sun, 19 Jun 2022 04:00:48 +0000

Serialization is converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.

Design an algorithm to serialize and deserialize a binary search tree. There is no restriction on how your serialization/deserialization algorithm should work. You need to ensure that a binary search tree can be serialized to a string, and this string can be deserialized to the original tree structure.

The encoded string should be as compact as possible.

Example 1:

Input: root = [2,1,3]
Output: [2,1,3]

Example 2:

Input: root = []
Output: []

Constraints:

The number of nodes in the tree is in the range [0, 104].
0 <= Node.val <= 104
The input tree is guaranteed to be a binary search tree.

SOLUTION:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Codec:

    def serialize(self, root: Optional[TreeNode]) -> str:
        tree = {}
        paths = [(root, 0)]
        while len(paths) > 0:
            curr, i = paths.pop()
            if curr:
                tree[i] = curr.val
                paths.append((curr.left, 2 * i + 1))
                paths.append((curr.right, 2 * i + 2))
        return ";".join(["{}={}".format(k, v) for k, v in tree.items()])

    def deserialize(self, data: str) -> Optional[TreeNode]:
        vals = data.split(";")
        tree = {}
        for v in vals:
            if len(v) > 0:
                key, value = v.split("=")
                tree[int(key)] = int(value)
        if len(tree) == 0:
            return None
        root = TreeNode()
        paths = [(root, 0)]
        while len(paths) > 0:
            curr, i = paths.pop()
            curr.val = tree[i]
            if (2 * i + 1) in tree:
                curr.left = TreeNode()
                paths.append((curr.left, 2 * i + 1))
            if (2 * i + 2) in tree:
                curr.right = TreeNode()
                paths.append((curr.right, 2 * i + 2))
        return root

# Your Codec object will be instantiated and called as such:
# Your Codec object will be instantiated and called as such:
# ser = Codec()
# deser = Codec()
# tree = ser.serialize(root)
# ans = deser.deserialize(tree)
# return ans

Valid Palindrome

Abhishek Choudhary — Sun, 19 Jun 2022 03:30:36 +0000

A phrase is a palindrome if, after converting all uppercase letters into lowercase letters and removing all non-alphanumeric characters, it reads the same forward and backward. Alphanumeric characters include letters and numbers.

Given a string s, return true if it is a palindrome, or false otherwise.

Example 1:

Input: s = "A man, a plan, a canal: Panama"
Output: true
Explanation: "amanaplanacanalpanama" is a palindrome.

Example 2:

Input: s = "race a car"
Output: false
Explanation: "raceacar" is not a palindrome.

Example 3:

Input: s = " "
Output: true
Explanation: s is an empty string "" after removing non-alphanumeric characters.
Since an empty string reads the same forward and backward, it is a palindrome.

Constraints:

1 <= s.length <= 2 * 105
s consists only of printable ASCII characters.

SOLUTION:

class Solution:
    def isPalindrome(self, s: str) -> bool:
        s = "".join([c.lower() for c in s if c.isalnum()])
        return s == s[::-1]

Average Salary Excluding the Minimum and Maximum Salary

Abhishek Choudhary — Sun, 19 Jun 2022 03:00:41 +0000

You are given an array of unique integers salary where salary[i] is the salary of the ith employee.

Return the average salary of employees excluding the minimum and maximum salary. Answers within 10-5 of the actual answer will be accepted.

Example 1:

Input: salary = [4000,3000,1000,2000]
Output: 2500.00000
Explanation: Minimum salary and maximum salary are 1000 and 4000 respectively.
Average salary excluding minimum and maximum salary is (2000+3000) / 2 = 2500

Example 2:

Input: salary = [1000,2000,3000]
Output: 2000.00000
Explanation: Minimum salary and maximum salary are 1000 and 3000 respectively.
Average salary excluding minimum and maximum salary is (2000) / 1 = 2000

Constraints:

3 <= salary.length <= 100
1000 <= salary[i] <= 106
All the integers of salary are unique.

SOLUTION:

class Solution:
    def average(self, salary: List[int]) -> float:
        n = len(salary)
        total = 0
        currmin = float('inf')
        currmax = float('-inf')
        for i in range(n):
            currmin = min(currmin, salary[i])
            currmax = max(currmax, salary[i])
            total += salary[i]
        return (total - currmin - currmax) / (n - 2)

Backspace String Compare

Abhishek Choudhary — Sun, 19 Jun 2022 02:30:40 +0000

Given two strings s and t, return true if they are equal when both are typed into empty text editors. '#' means a backspace character.

Note that after backspacing an empty text, the text will continue empty.

Example 1:

Input: s = "ab#c", t = "ad#c"
Output: true
Explanation: Both s and t become "ac".

Example 2:

Input: s = "ab##", t = "c#d#"
Output: true
Explanation: Both s and t become "".

Example 3:

Input: s = "a#c", t = "b"
Output: false
Explanation: s becomes "c" while t becomes "b".

Constraints:

1 <= s.length, t.length <= 200
s and t only contain lowercase letters and '#' characters.

Follow up: Can you solve it in O(n) time and O(1) space?

SOLUTION:

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        ss = ""
        tt = ""
        for c in s:
            if c == "#":
                ss = ss[:-1]
            else:
                ss += c
        for c in t:
            if c == "#":
                tt = tt[:-1]
            else:
                tt += c
        return ss == tt

Maximum Erasure Value

Abhishek Choudhary — Sun, 19 Jun 2022 02:00:46 +0000

You are given an array of positive integers nums and want to erase a subarray containing unique elements. The score you get by erasing the subarray is equal to the sum of its elements.

Return the maximum score you can get by erasing exactly one subarray.

An array b is called to be a subarray of a if it forms a contiguous subsequence of a, that is, if it is equal to a[l],a[l+1],...,a[r] for some (l,r).

Example 1:

Input: nums = [4,2,4,5,6]
Output: 17
Explanation: The optimal subarray here is [2,4,5,6].

Example 2:

Input: nums = [5,2,1,2,5,2,1,2,5]
Output: 8
Explanation: The optimal subarray here is [5,2,1] or [1,2,5].

Constraints:

1 <= nums.length <= 105
1 <= nums[i] <= 104

SOLUTION:

class Solution:
    def maximumUniqueSubarray(self, nums: List[int]) -> int:
        n = len(nums)
        msum = 0
        p = [0]
        for el in nums:
            p.append(p[-1] + el)
        prev = {}
        i = 0
        for j in range(n):
            if nums[j] in prev:
                i = max(i, prev[nums[j]] + 1)
            msum = max(msum, p[j + 1] - p[i])
            prev[nums[j]] = j
        return msum

Balance a Binary Search Tree

Abhishek Choudhary — Sun, 19 Jun 2022 01:30:42 +0000

Given the root of a binary search tree, return a balanced binary search tree with the same node values. If there is more than one answer, return any of them.

A binary search tree is balanced if the depth of the two subtrees of every node never differs by more than 1.

Example 1:

Input: root = [1,null,2,null,3,null,4,null,null]
Output: [2,1,3,null,null,null,4]
Explanation: This is not the only correct answer, [3,1,4,null,2] is also correct.

Example 2:

Input: root = [2,1,3]
Output: [2,1,3]

Constraints:

The number of nodes in the tree is in the range [1, 104].
1 <= Node.val <= 105

SOLUTION:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorder(self, root):
        if root:
            self.inorder(root.left)
            self.tree.append(root.val)
            self.inorder(root.right)

    def arrToTree(self, arr, i, j):
        if i <= j - 1:
            root = TreeNode()
            mid = (i + j) // 2
            root.val = arr[mid]
            root.left = self.arrToTree(arr, i, mid)
            root.right = self.arrToTree(arr, mid + 1, j)
            return root
        return None

    def balanceBST(self, root: TreeNode) -> TreeNode:
        self.tree = []
        self.inorder(root)
        return self.arrToTree(self.tree, 0, len(self.tree))

Smallest String With Swaps

Abhishek Choudhary — Sun, 19 Jun 2022 01:00:46 +0000

You are given a string s, and an array of pairs of indices in the string pairs where pairs[i] = [a, b] indicates 2 indices(0-indexed) of the string.

You can swap the characters at any pair of indices in the given pairs any number of times.

Return the lexicographically smallest string that s can be changed to after using the swaps.

Example 1:

Input: s = "dcab", pairs = [[0,3],[1,2]]
Output: "bacd"
Explaination:
Swap s[0] and s[3], s = "bcad"
Swap s[1] and s[2], s = "bacd"

Example 2:

Input: s = "dcab", pairs = [[0,3],[1,2],[0,2]]
Output: "abcd"
Explaination:
Swap s[0] and s[3], s = "bcad"
Swap s[0] and s[2], s = "acbd"
Swap s[1] and s[2], s = "abcd"

Example 3:

Input: s = "cba", pairs = [[0,1],[1,2]]
Output: "abc"
Explaination:
Swap s[0] and s[1], s = "bca"
Swap s[1] and s[2], s = "bac"
Swap s[0] and s[1], s = "abc"

Constraints:

1 <= s.length <= 10^5
0 <= pairs.length <= 10^5
0 <= pairs[i][0], pairs[i][1] < s.length
s only contains lower case English letters.

SOLUTION:

from collections import defaultdict

class Solution:
    def dfs(self, graph, node, visited):
        for j in graph[node]:
            if j not in visited:
                visited.add(j)
                self.dfs(graph, j, visited)

    def smallestStringWithSwaps(self, s: str, pairs: List[List[int]]) -> str:
        op = list(s)
        graph = defaultdict(list)
        for a, b in pairs:
            graph[a].append(b)
            graph[b].append(a)
        globalvisited = set()
        for x in graph:
            if x not in globalvisited:
                currvisited = {x}
                self.dfs(graph, x, currvisited)
                indexes = sorted(currvisited)
                indexes_asc = sorted(currvisited, key = lambda p: s[p])
                n = len(indexes)
                for i in range(n):
                    op[indexes[i]] = s[indexes_asc[i]]
                globalvisited.update(currvisited)
        return "".join(op)

Crawler Log Folder

Abhishek Choudhary — Sun, 19 Jun 2022 00:30:36 +0000

The Leetcode file system keeps a log each time some user performs a change folder operation.

The operations are described below:

"../" : Move to the parent folder of the current folder. (If you are already in the main folder, remain in the same folder).
"./" : Remain in the same folder.
"x/" : Move to the child folder named x (This folder is guaranteed to always exist).

You are given a list of strings logs where logs[i] is the operation performed by the user at the ith step.

The file system starts in the main folder, then the operations in logs are performed.

Return the minimum number of operations needed to go back to the main folder after the change folder operations.

Example 1:

Input: logs = ["d1/","d2/","../","d21/","./"]
Output: 2
Explanation: Use this change folder operation "../" 2 times and go back to the main folder.

Example 2:

Input: logs = ["d1/","d2/","./","d3/","../","d31/"]
Output: 3

Example 3:

Input: logs = ["d1/","../","../","../"]
Output: 0

Constraints:

1 <= logs.length <= 103
2 <= logs[i].length <= 10
logs[i] contains lowercase English letters, digits, '.', and '/'.
logs[i] follows the format described in the statement.
Folder names consist of lowercase English letters and digits.

SOLUTION:

class Solution:
    def minOperations(self, logs: List[str]) -> int:
        ctr = 0
        for log in logs:
            if log == "../":
                ctr =  max(ctr - 1, 0)
            elif log != "./":
                ctr += 1
        return ctr

Remove Palindromic Subsequences

Abhishek Choudhary — Sun, 19 Jun 2022 00:00:45 +0000

You are given a string s consisting only of letters 'a' and 'b'. In a single step you can remove one palindromic subsequence from s.

Return the minimum number of steps to make the given string empty.

A string is a subsequence of a given string if it is generated by deleting some characters of a given string without changing its order. Note that a subsequence does not necessarily need to be contiguous.

A string is called palindrome if is one that reads the same backward as well as forward.

Example 1:

Input: s = "ababa"
Output: 1
Explanation: s is already a palindrome, so its entirety can be removed in a single step.

Example 2:

Input: s = "abb"
Output: 2
Explanation: "abb" -> "bb" -> "".
Remove palindromic subsequence "a" then "bb".

Example 3:

Input: s = "baabb"
Output: 2
Explanation: "baabb" -> "b" -> "".
Remove palindromic subsequence "baab" then "b".

Constraints:

1 <= s.length <= 1000
s[i] is either 'a' or 'b'.

SOLUTION:

class Solution:
    def removePalindromeSub(self, s: str) -> int:
        if s == s[::-1]:
            return 1
        return 2