I had two files that contained two halves of the transcript of an audio recording and I wanted to use an LLM to merge the two halves.\nThere were three reasons that stopped me from simply copying part 2 and pasting it after part 1:<\/p>\n
- \n
- the two transcripts overlapped (the end of part 1 was after the start of part 2);<\/li>\n
- the timestamps for part 2 started from 0, so they were missing an offset; and<\/li>\n
- speaker identification was not consistent.<\/li>\n<\/ol>\n
I uploaded the two halves into ChatGPT and asked it to merge the two transcripts, fix the timestamps and the speaker identification, but to not change the text.<\/p>\n
The result I got back was a ridiculous attempt at providing the full transcript, with two sections that supposedly represented parts of either transcript I could just copy and paste confidently, and a couple of other ridiculous blunders.<\/p>\n
Instead of fighting ChatGPT, I decided to use a very useful pattern I learned about last year.<\/p>\n
Ask the LLM to write code for it<\/a><\/h2>\n
Instead of asking ChatGPT to merge the transcripts, I could ask it to analyse them, find the solutions to the three problems listed above, and then write code that would merge the transcripts.<\/p>\n
Since I was confident that ChatGPT could<\/p>\n
- \n
- identify the overlap between the two files;<\/li>\n
- use the overlap information to compute the timestamp offset required for part 2; and<\/li>\n
- figure out you had to swap the two speakers in part 2,<\/li>\n<\/ol>\n
I knew ChatGPT would be able to write a Python script that could read from both files and apply a couple of string operations to the second part.<\/p>\n
This yielded much better results in two ways.\nChatGPT was able to find the solutions for the three problems above and write a script that fixed them automatically.\nThat was the goal.<\/p>\n
On top of that, since ChatGPT had a very clear implicit goal \u2014 get the final merged transcript \u2014 and since running Python code is something that ChatGPT can do, ChatGPT even ran the script for me and produced two artifacts at the end:<\/p>\n
- \n
- the full Python script I could run against the two halves if I wanted; and<\/li>\n
- the final, fixed transcript.<\/li>\n<\/ol>\n
This is an example application of a really useful LLM pattern:<\/p>\n
\n
Don't ask the LLM to solve a problem. Instead, ask it to write code that solves the problem.<\/p>\n<\/blockquote>\n
As another visual example, it's much easier to ask an LLM to write a Python script that draws a path that solves a maze (that's just a couple hundred of lines of code) than it is to upload an image and ask the LLM to draw a valid path<\/em> on the picture of a maze.\nTry it yourself!<\/p>","summary":"This article covers a useful LLM pattern where you ask the LLM to write code to solve a problem instead of asking it to solve the problem directly.","date_modified":"2026-07-06T16:16:52+02:00","tags":["python","programming","llms","slice of life"],"image":"\/user\/pages\/02.blog\/ask-the-llm-to-write-code-for-it\/thumbnail.webp"},{"title":"Regex in real life","date_published":"2025-06-08T17:34:00+02:00","id":"https:\/\/mathspp.com\/blog\/regex-in-real-life","url":"https:\/\/mathspp.com\/blog\/regex-in-real-life","content_html":"
This article shows how I have used regex in real life for all sorts of tasks.<\/p>\n\n
I love keeping track of real-life examples of the usage of certain features and regex is one of those things, so in this article you will find real-life examples of how\/where I used regular expressions to do all sorts of tasks.<\/p>\n
As I use regex in new and interesting ways, I will update this article to include those examples.<\/p>\n
Mass-reformatting hints to some exercises<\/a><\/h2>\n
I was working on some exercises for my intermediate Python course<\/a> and they all had this format:<\/p>\n
#### Exercise ?\nProblem statement goes here.\n\n*Hint: exercise hint goes here.*<\/code><\/pre>\nI wanted to reformat this so that the hints weren't shown by default, so I wanted to have this:<\/p>\n
#### Exercise ?\nProblem statement goes here.\n\n<details>\n<summary>Hint:<\/summary>\n\nExercise hint goes here.\n\n<\/details><\/code><\/pre>\nI could easily search for
\\*Hint: (.*)\\*<\/code>, giving me all the lines with hints, and just as easily I could replace that with the<details><\/code>\/<summary><\/code> tags...\nBut then I would still have hundreds of lines to fix, because the first line of the problem hint was in lowercase in the original text and I wanted it uppercase now, since the hint is now a standalone sentence...<\/p>\nThankfully, VS Code allows you to do search & replace operations that modify the casing of the matches<\/a>, so that's what I ended up doing.\nI didn't even need to bring out Python to do this. 😅<\/p>\n
Compiling a numbered list of tip titles<\/a><\/h2>\n
For my newsletter Python drops 🐍💧<\/a>, I keep a list of all previous tips titles so that people can see what they're missing out on.\nTo compile this list, I run a short script that traverses the directory where the tips are and finds their number and title.<\/p>\n
This is the rough directory structure:<\/p>\n
|- 0001-zip_strict_true\n |- tip.md\n|- 0002-string_casefold_case-insensitive_comparison\n |- tip.md\n|- 0003_type_unions_with_pipe\n |- tip.md\n...<\/code><\/pre>\nEach directory contains some other files, but I only care about the files
**\/tip.md<\/code> for the purposes of this specific task.\nI want to check each filetip.md<\/code> and extract the tip number and title.<\/p>\nAs an example, this is what the file
0003_type_unions_with_pipe\/tip.md<\/code> looks like:<\/p>\n---\nthemes:\n - \"typing\/type hints\"\n - \"`isinstance`\"\n - \"vertical bar `|`\"\n - \"type unions\"\n---\n\n## 3 – Type unions with the vertical bar in `isinstance`\n\n...<\/code><\/pre>\nAssuming all files
tip.md<\/code> have a title in the same format, I can use regex to extract them:<\/p>\nTITLE_PATTERN = re.compile(r\"(?m)^## (?P<nr>\\d{1,4}) – (?P<title>.*)$\")<\/code><\/pre>\nThis neat little pattern uses a couple of nice regex features.<\/p>\n
By using the inline flag
(?m)<\/code>, I make sure that the special characters^<\/code> and$<\/code> match the beginning and end of every new line, respectively, instead of only matching the beginning and end of the string.<\/p>\nI also use named groups with the syntax
(?P<group_name>...)<\/code>, which allows me to refer to the parts of the match that I care about by name, instead of having to figure...<\/p>","summary":"This article shows how I have used regex in real life for all sorts of tasks.","date_modified":"2025-09-03T02:19:00+02:00","tags":["regex","python","programming","slice of life"],"image":"\/user\/pages\/02.blog\/regex-in-real-life\/thumbnail.webp"},{"title":"Beating LinkedIn \u201cQueens\u201d with Python","date_published":"2025-02-25T18:40:00+01:00","id":"https:\/\/mathspp.com\/blog\/beating-linkedin-queens-with-python","url":"https:\/\/mathspp.com\/blog\/beating-linkedin-queens-with-python","content_html":"This is a short account of how I wrote a program that solves all LQueens puzzles from LinkedIn automatically with Python.<\/p>\n\n
About a year ago LinkedIn started publishing a daily logic puzzle called “Queens”.\nThis puzzle is a crossover between the queen-placing puzzle from chess<\/a> and Sudoku, and takes place in a square grid with a number of heterogeneous coloured regions, as the image below demonstrates:<\/p>\n
![A screenshot showing the text \"Puzzle 179 Appeared on 26 October 2024\" and a coloured grid that is 8 by 8 with 8 coloured regions of heterogeneous shapes.](\"\/user\/pages\/02.blog\/beating-linkedin-queens-with-python\/_puzzle.webp\" "\\"Queens")
Queens puzzle #179.<\/figcaption><\/figure> Puzzle rules<\/a><\/h2>\n
The rules for the puzzle are quite simple.\nYou have to place one queen on each coloured region while also making sure that:<\/p>\n
- there is one and only one queen per row and column; and<\/li>\n
- queens cannot touch each other, not even diagonally.<\/li>\n<\/ul>
See if you can solve the puzzle above, for example by visiting this unofficial archive<\/a>.\n(Make sure to select the same puzzle as I'm showing above, number 179.)<\/p>\n
Solving the puzzle<\/a><\/h2>\n
I write algorithms for things like this all the time – which is a bit of a weird thing to be experienced on, but oh well... –, so solving the puzzle in Python was actually quite straightforward.<\/p>\n
I decided to represent the board as a list of sets, where each set contains the coordinates of the cells of a coloured region.\nFor example, puzzle 179 shown above would be represented as the following list of sets:<\/p>\n
[\n {(0, 1), (4, 0), (0, 0), (7, 0), (2, 0), (3, 0), ...}, # yellow\n {(7, 4), (7, 1), (2, 1), (7, 7), (3, 1), (6, 1), ...}, # orange\n {(2, 4), (0, 4), (0, 3), (1, 4), (0, 6), (0, 2), ...}, # blue\n {(2, 3), (3, 2), (1, 2), (2, 2)}, # green\n {(6, 2), (4, 3), (4, 2), (3, 3), (5, 2)}, # gray\n {(2, 5), (3, 4), (3, 5), (1, 5)}, # red\n {(4, 4), (5, 5), (6, 5), (5, 4), (4, 5)}, # purple\n {(0, 7), (2, 7), (3, 7), (4, 6), (5, 7), (1, 7), ...}, # brown\n]<\/code><\/pre>\nThe good stuff lies in the function
solve<\/code>.\nThe functionsolve<\/code> is a recursive function that accepts the list with coloured groups that don't have a queen yet and returns the list of positions where queens must go.<\/p>\nHow does the function know it's done?\nIf it receives an empty list of coloured groups, then that means all groups received a queen, and we can start producing the list of queen positions:<\/p>\n
def solve(group_sets):\n if not group_sets:\n return []\n\n # ...<\/code><\/pre>\nThat's the best possible scenario, because that's when the function is already done.\nBut usually, the function has work to do.<\/p>\n
If the list of coloured groups is not empty, then the function looks at the very first coloured group, which should be
group_sets[0]<\/code>, and traverses that set of positions, one position at a time:<\/p>\nfor tx, ty in group_sets[0]:<\/code><\/pre>\nThe
tx<\/code> andty<\/code> and the x and y coordinates for the tentative<\/em> position of the queen of the current coloured group.\nBut let us assume, for a second,...<\/p>","summary":"This is a short account of how I wrote a program that solves all Queens puzzles from LinkedIn automatically with Python.","date_modified":"2025-07-23T16:49:02+02:00","tags":["algorithms","image processing","python","programming","recursion","slice of life"],"image":"\/user\/pages\/02.blog\/beating-linkedin-queens-with-python\/thumbnail.webp"},{"title":"Automatic site updates with cog and pre-commit","date_published":"2024-08-09T19:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/automatic-site-updates-with-cog-and-pre-commit","url":"https:\/\/mathspp.com\/blog\/automatic-site-updates-with-cog-and-pre-commit","content_html":"This article outlines how I use a pre-commit hook and cog to keep my blog stats updated automatically.<\/p>\n\n
Some months ago I introduced some basic stats in my blog<\/a> that show how many articles I've published, along with how many words and lines of code those articles contain.\nI wrote an article explaining how I wrote a script that gathers these blog stats for me<\/a> but that's a script I still need to run and then manually update the stats.<\/p>\n
I wanted to automate this process but I couldn't bring myself to do it.\nAnd then, I came to the silly realisation that I could use ChatGPT to help me with the set up that I was dreading to do.<\/p>\n
Rewriting the stats with cog<\/a><\/h2>\n
Cog<\/a> is “a file generation tool” that lets you use snippets of Python code to fill in parts of other files.\nFor this particular project, I wanted it to rewrite the Markdown table that lists the blog stats<\/a>, that looks like this:<\/p>\n
...\n\n| 364 | 401,577 | 33,251 |\n| :-: | :-: | :-: |\n| articles | words | lines of code |\n\n...<\/code><\/pre>\nI already have a script
stats.py<\/code> that computes the stats, so I started by changing it to produce the output in this exact format.\nThen, I tweaked the markdown file to include a cog tag that runs the script and inserts its output in the markdown file.\nThe markdown file now looks like this:<\/p>\n...\n\n<!--\n[[[cog\nimport cog, subprocess\nresult = subprocess.run([\"python\", \"pages\/02.blog\/stats.py\"], text=True, capture_output=True)\ncog.outl(result.stdout)\n]]]-->\n| 364 | 401,577 | 33,251 |\n| :-: | :-: | :-: |\n| articles | words | lines of code |\n<!--[[[end]]]--->\n\n...<\/code><\/pre>\nThe
[[[cog<\/code> part tells cog where my Python code starts and the]]]<\/code> tells it where it ends.\nIn my case, I'm just using the modulesubprocess<\/code> to run the script I already have, I'm capturing its output, and I'm reemitting the output through cog.<\/p>\nThe output that I produce with
cog.outl<\/code> is then inserted between the]]]<\/code> and the[[[end]]]<\/code>, which is where the table ends up being.\nIn case you're wondering, for every run cog will start by clearing the previous table and then will write the new one.<\/p>\nFinally, note that the cog tags are surrounded by HTML multi-line comments, so that the cog tags themselves do not show up in the final page.\nAt least, not visibly.\nIf you inspect the source code of my blog page<\/a> you will see the HTML comments with the cog tags there.<\/p>\n
Triggering cog automatically with pre-commit<\/a><\/h2>\n
The thing with cog is that I still have to run
cog -r blog.md<\/code> to update the table, so my next step is to automate the step that calls cog.\nFor that, I asked ChatGPT to help me set up a pre-commit hook<\/a> that is triggered when my blog pages change.<\/p>\nAfter a couple of exchanges with ChatGPT, I ended up with the following
.pre-commit-config.yaml<\/code> file<\/a>...<\/p>","summary":"This article outlines how I use a pre-commit hook and cog to keep my blog stats updated automatically.","date_modified":"2026-07-06T16:16:52+02:00","tags":["git","llms","productivity","programming","python","scripting","slice of life"],"image":"\/user\/pages\/02.blog\/automatic-site-updates-with-cog-and-pre-commit\/thumbnail.webp"},{"title":"Dynamic string replacements with regex","date_published":"2024-01-09T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/dynamic-string-replacements-with-regex","url":"https:\/\/mathspp.com\/blog\/dynamic-string-replacements-with-regex","content_html":"Learn how to find text patterns and replace them with dynamic content using regex.<\/p>\n\n
The other day I was working on my problems book<\/a> and I needed to update a markdown file to number the headings.\nIn short, I had a markdown file like this:<\/p>\n
# Problems\n\n## Dancing triangle\n\n...\n\n## Bag full of numbers\n\n...\n\n## Quarrel in the Shire\n\n...<\/code><\/pre>\nI wanted to find all H2 headings and number them, so I'd end up with this file:<\/p>\n
# Problems\n\n## 01 – Dancing triangle\n\n...\n\n## 02 – Bag full of numbers\n\n...\n\n## 03 – Quarrel in the Shire\n\n...<\/code><\/pre>\nI thought about doing this manually but I'd need to do this to 2 documents, each with thousands of lines and 64 headings, so I decided to use a bit of Python and regex to do it.<\/p>\n
The module
re<\/code>, from the Python standard library, lets you do string replacements with the functionre.sub<\/code><\/a>, which needs 3 parameters:<\/p>\n- the pattern we're looking for;<\/li>\n
- the replacement for the pattern; and<\/li>\n
- the string we're searching & replacing in.<\/li>\n<\/ol>
re.sub<\/code> is like the string methodstr.replace<\/code> on steroids!<\/p>\nIn my case, the pattern I was looking for was this:<\/p>\n
^## (.*)$<\/code><\/pre>\nThis looks for a
##<\/code> at the beginning of the line, followed by a space, and then the(.*)$<\/code> matches everything else until the end of the line.<\/p>\nWe can see this in action if we use
re.findall<\/code> and a dummy string:<\/p>\n>>> import re\n>>> string = '# Problems\\n\\n## Dancing triangle\\n\\n...\\n\\n## Bag full of numbers\\n\\n...\\n\\n## Quarrel in the Shire\\n\\n...'\n>>> re.findall(\"^## (.*)$\", string, flags=re.MULTILINE)\n[\n 'Dancing triangle',\n 'Bag full of numbers',\n 'Quarrel in the Shire'\n]<\/code><\/pre>\nThe flag
re.MULTILINE<\/code> was used so that the anchors^<\/code> and$<\/code> matche the beginning and end of each line, respectively, instead of the beginning and end of the string.<\/p>\n(Go to regex101<\/a> (an online regex playground), paste the regular expression
^## (.*)$<\/code> in the top, middle bar, and copy and paste the first version of the# Problems<\/code> markdown in the big, central text area.)<\/p>\nThe next thing I wanted was to be able to replace each title with a number followed by
–<\/code> and then itself!\nBy using group references, adding the–<\/code> before the title is easy:<\/p>\n>>> print(\n... re.sub(\"^## (.*)$\", r\"## xx – \\1\", string, flags=re.MULTILINE)\n... )\n# Problems\n\n## xx – Dancing triangle\n\n...\n\n## xx – Bag full of numbers\n\n...\n\n## xx – Quarrel in the Shire\n\n...<\/code><\/pre>\nThe “difficult” part is adding the number that must be incremented each time we add it.\nThankfully, the function
re.sub<\/code> has a trick up its sleeve!<\/p>\nThe second parameter of the function
re.sub<\/code>, which is the replacement, can be a function<\/em>.\nThis function must have a single parameter, which is the match object, and must return a string, which is the replacement for the given match.\nThus, by using a counter variable, I can add these increasing IDs:<\/p>\n>>> counter...<\/code><\/pre>","summary":"Learn how to find text patterns and replace them with dynamic content using regex.","date_modified":"2025-11-22T09:33:35+01:00","tags":["programming","python","regex","slice of life"],"image":"\/user\/pages\/02.blog\/dynamic-string-replacements-with-regex\/thumbnail.webp"},{"title":"Secret Santa draw with Python","date_published":"2023-11-22T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/secret-santa-draw-with-python","url":"https:\/\/mathspp.com\/blog\/secret-santa-draw-with-python","content_html":"This article shows how I made a secret Santa draw with Python.<\/p>\n\n
Today I needed to make a Secret Santa draw for my whole family.\nThere are lots of services online that do this for you, but they require giving those services the emails of my family members who will then be mercilessly spammed by said services...<\/p>\n
So I decided to make my own draw with a bit of Python programming.\nAll I needed was:<\/p>\n
- to be able to input the names of my family members; and<\/li>\n
- to be able to set exclusion groups so that family members don't draw the names of others in their nuclear family (for example, I don't want to be able to draw the name of my own brother).<\/li>\n<\/ul>
This article is my account of how I did it, bit by bit, on the REPL.\nI'll try to describe briefly what each objective was at each point in time.\nYou'll see that the code isn't particularly well structured but it shows an accurate depiction of real code I wrote to solve a real-life need I had.<\/p>\n
Specifying the names<\/a><\/h2>\n
The first thing I did was specify the names of everyone that was participating in the draw.\nWithout giving it too much thought, I figured this looked like a reasonable way of doing it:<\/p>\n
names = [\n [\"Alfred\", \"Ana\", \"Arthur\"],\n [\"Ben\", \"Beatrice\", \"Bianca\"],\n [\"Charles\", \"Catherine\"],\n [\"David\"],\n [\"Edward\", \"Elaine\", \"Eve\"],\n]<\/code><\/pre>\nThe idea is that each sublist represents a nuclear family, so we wouldn't want Alfred to draw Ana's or Arthur's name, but he could draw any other name starting with B, C, D, or E.<\/p>\n
A flat list with all participants<\/a><\/h2>\n
The next step, I figured, was to get a flat list with all<\/em> of the participants, so that I could easily shuffle them around.<\/p>\n
Flattening a list of lists is easy if you know what to do:<\/p>\n
from itertools import chain\nflat_names = list(chain.from_iterable(names))\nprint(flat_names) # ['Alfred', 'Ana', 'Arthur', 'Ben', ...]<\/code><\/pre>\nCreating a more manageable data structure for exclusions<\/a><\/h2>\n
As I was getting ready to shuffle things around, I figured I'd need a quick and easy way to take a pair of names and figure out if they were in the same exclusion group or not.<\/p>\n
To do this, I created a dictionary that maps each single name into its exclusion group.\nI used a dictionary comprehension, which is aking to a list comprehension<\/a>, but for dictionaries.<\/p>\n
This dictionary adds some redundancy, but it's easier to work with:<\/p>\n
exclusions = {name: group for group in names for name in group}\nprint(exclusions)\n\"\"\"\n{\n 'Alfred': ['Alfred', 'Ana', 'Arthur'],\n 'Ana': ['Alfred', 'Ana', 'Arthur'],\n 'Arthur': ['Alfred', 'Ana', 'Arthur'],\n 'Ben': ['Ben', 'Beatrice', 'Bianca'],\n # ...\n}\n\"\"\"<\/code><\/pre>\nDrawing names<\/a><\/h2>\n
The next step was generating the actual draw.\nI didn't feel like thinking too much about it, so I thought I'd go with brute-force, randomising the draw and then repeating the draw until all exclusion requirements were met by coincidence.<\/p>\n
To achieve this, I wrote this
for<\/code> loop:<\/p>\nimport...<\/code><\/pre>","summary":"This article shows how I made a secret Santa draw with Python.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","scripting","slice of life"],"image":"\/user\/pages\/02.blog\/secret-santa-draw-with-python\/thumbnail.webp"},{"title":"Adding stats to my blog","date_published":"2023-10-03T07:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/adding-stats-to-my-blog","url":"https:\/\/mathspp.com\/blog\/adding-stats-to-my-blog","content_html":"This explains how I added stats to my blog page.<\/p>\n\n
![\"Screenshot](\"\/images\/9\/b\/5\/a\/6\/9b5a64afaf29472c9e64bd227aebf8f3b97498ea-stats.png\" "\\"Screenshot")
Screenshot of the blog page.<\/figcaption><\/figure> I recently added some basic statistics to my blog, as the image above shows.\nThese statistics include the total number of articles published, the number of lines of code written, and the number of words written.<\/p>\n
I wrote a Python script to do this for me, naturally, and I wanted to go over it with you.<\/p>\n
Find blog articles<\/a><\/h2>\n
The first thing I did was write a function that finds all blog posts.\nThis function expects a folder location and it will find all Markdown files that look like blog posts.\nIn my blog, articles are files called
item.md<\/code> oritem.en.md<\/code> inside their respective folder, which may be nested arbitrarily, inside a folder where all blog articles reside.<\/p>\nRecursively finding files whose name matches a simple pattern can be done by the module
pathlib<\/code><\/a> and the methodrglob<\/code><\/a> that path objects have.\nThe final function looks like this:<\/p>\nfrom pathlib import Path\n\ndef find_files(folder):\n yield from Path(folder).rglob(\"item*.md\")<\/code><\/pre>\nThanks to
pathlib<\/code>, this is short enough!\nI then opened a REPL inside my blog directory structure<\/a> and tested this function:<\/p>\n>>> from stats import find_files\n>>> next(find_files(\".\"))\nPosixPath('smoosh-all-the-things\/item.md')<\/code><\/pre>\nThe function
find_files<\/code> can also be used to count how many articles I have:<\/p>\n>>> len(list(find_files(\".\")))\n293<\/code><\/pre>\nRemove optional frontmatter<\/a><\/h2>\n
The next thing I want to do is to get rid of metadata that blog articles might have.\nSome of my articles will have an initial section that is delimited by three dashes
---<\/code>, and that section contains metadata about the article (for example, the title or the date it was published on) and I don't want to take that into account when computing stats for each article.<\/p>\nFor example, an article might look like this:<\/p>\n
---\ndate: 01-01-2023\ntitle: Happy New Year\n---\n\nHey there, in this article I wish you a happy new year!<\/code><\/pre>\nSo, my next step was to create a function that takes in the path to a Markdown article and returns its useful content, possibly stripping it from its frontmatter.\nThis is the function I wrote:<\/p>\n
# ...\n\ndef get_file_contents(filepath):\n contents = Path(filepath).read_text()\n if contents.startswith(\"---\"):\n contents = contents.removeprefix(\"---\")\n contents = contents[3 + contents.find(\"---\") :]\n return contents<\/code><\/pre>\nThis function will slice out the frontmatter, in case its present, and it will return the useful contents of the article.<\/p>\n
Split code from prose<\/a><\/h2>\n
The next processing step is taking in the article and splitting the prose from the code snippets.\nCode snippets are surrounded by triple backticks ```, so I can use a regular expression to look for those blocks.<\/p>\n
The module
re<\/code> contains a functionsub<\/code> that lets me substitute text.\nSo, what I did was to find all the blocks that are surrounded by triple backticks and substitute them with the empty string\"\"<\/code>.\nHowever, I also want to extract<\/em> the blocks, not just remove them from the prose.<\/p>\nIn order to extract<\/em> the blocks, I used the fact that the...<\/p>","summary":"This explains how I added stats to my blog page.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","slice of life"],"image":"\/user\/pages\/02.blog\/adding-stats-to-my-blog\/_stats.png"},{"title":"Converting RAW images into JPEG","date_published":"2023-03-04T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/converting-raw-images-into-jpeg","url":"https:\/\/mathspp.com\/blog\/converting-raw-images-into-jpeg","content_html":"
Learn how I used Python in my daily life to convert 5,000 RAW images into the JPEG format.<\/p>\n\n
Introduction<\/a><\/h2>\n
I have a folder with 4,902 RAW images and I want to convert them into the format JPEG to make it easier to share them with friends and family.<\/p>\n
I wasn't sure how I would convert almost 5,000 RAW images into another format but Python had my back.\nA quick Google search brought up a similar Stack Overflow question<\/a> from someone trying to do something similar.<\/p>\n
I installed the modules
rawpy<\/code> andimageio<\/code> withpython -m pip install rawpy imageio<\/code> and it took me a couple of lines of code to convert my first image.<\/p>\nI added a loop to go over all the images, I added a Rich<\/a> progress bar to see my code working, and I was done.<\/p>\n
Here is a screenshot of the code showing the progress bar, so I know it is still doing work:<\/p>\n
![\"Screenshot](\"\/user\/pages\/02.blog\/converting-raw-images-into-jpeg\/_working.webp\" "\\"The")
The progress bar during the execution of the script.<\/figcaption><\/figure>\n The full code for this script can be found below.\nNow, I wonder...\nHow much time would I have spent if I did not know Python?!<\/p>\n
\"\"\"\nConvert NEF images into JPG.\n\nCredit to https:\/\/stackoverflow.com\/q\/59054975\/2828287 and https:\/\/stackoverflow.com\/a\/66048939\/2828287.\n\"\"\"\n\nimport pathlib\n\nimport imageio\nimport rawpy\nfrom rich.progress import track\n\nFROM = pathlib.Path(...) # Folder to read from.\nTO = pathlib.Path(...) # Folder to save images into.\n\nimages = list(FROM.glob(\"*\"))\n\nfor img in track(images):\n with rawpy.imread(str(img)) as raw:\n rgb = raw.postprocess(rawpy.Params(use_camera_wb=True))\n new_location = (TO \/ img.name).with_suffix(\".jpg\")\n imageio.imsave(new_location, rgb)<\/code><\/pre>","summary":"Learn how I used Python in my daily life to convert 5,000 RAW images into the JPEG format.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","scripting","slice of life"],"image":"\/user\/pages\/02.blog\/converting-raw-images-into-jpeg\/thumbnail.webp"},{"title":"Finding similar photos","date_published":"2023-02-01T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/finding-similar-photos","url":"https:\/\/mathspp.com\/blog\/finding-similar-photos","content_html":"Go through the complete code for a Python project that consists in finding similar photographs in a folder. This tutorial will make use of classical techniques and is suitable for beginners.<\/p>\n\n
![\"\"](\"\/images\/a\/2\/1\/1\/9\/a21191c1e958cd25ee5aea62e3e43592c1bb5842-thumbnail.webp\")
<\/p>\nIntroduction<\/a><\/h2>\n
The photo gallery on my phone is consistently packed with photos that all look (pretty much) the same.\nGoing through batches of photos and looking for near-duplicates is boring, so I thought I would try to use some maths and some Python to help me find images that are very close to one another.<\/p>\n
For example, I would like my program to determine that the first two photos in the collage below are pretty much the same, while also saying that the third one is different from the other two.<\/p>\n
![\"A](\"\/user\/pages\/02.blog\/finding-similar-photos\/_seagulls.webp\" "\\"Three")
Three photos of the same seagull.<\/figcaption><\/figure> This short tutorial will go through the (surprisingly little) code I wrote as an experiment.<\/p>\n
Tooling<\/a><\/h2>\n
This short project makes use of the pillow<\/a> imaging library for Python and does not<\/strong> use any machine learning.\nTo determine our near-duplicate photos, we will be using rudimentary image processing techniques.<\/p>\n
GitHub repository<\/a><\/h2>\n
Code<\/a><\/h3>\n
The code for this project can be found in the “Finding similar images” GitHub repo<\/a>.\nFeel free to star the repository and fork it to play around with the code.<\/p>\n
To get started using the code,<\/p>\n
- clone the repository;<\/li>\n
- run
poetry install<\/code> to install the pillow<\/a> dependency (or install it by hand, if you must); and<\/li>\n- run
python src\/similarity.py<\/code>.<\/li>\n<\/ol>Images
- run