Python on Janusworx

Hack Hugo Post Metadata With Python

feedback@janusworx.com (Mario Jason Braganza) — Mon, 03 Feb 2025 09:33:37 +0530

A while back, I rejigged the sections on my site to better reflect how I think and write.
Which meant, all the urls, on all my posts changed, since they now used the new category as a slug, instead of ye old /blog.

For e.g. https://janusworx.com/blog/using-hugo-variables-to-help-with-mailto-links-in-hugo/ …
was now at, https://janusworx.com/work/using-hugo-variables-to-help-with-mailto-links-in-hugo/

After searching a bit, I found that Hugo supported aliases. For me, it would redirect the original /blog path url to its new location
Ass I had to do, was add an aliases: ["/blog/old-post-slug"] line to each post’s metadata.¹
Line 4 in the snippet below shows, what I added to fix the post above.

1
2
3
4
5
6
7
8


---
title: "Using Hugo Variables to Help With Mailto Links in Hugo"
date: 2024-05-30T18:17:35+05:30
aliases: ["/blog/using-hugo-variables-to-help-with-mailto-links-in-hugo"]
categories: ["work"]
tags: [100WordHabit, Dgplug, Hugo]
summary: Shortcodes! Hugo Variables in Shortcodes!
---

I did not want to do this by hand for 800+ posts.
One stroke of luck for me, was that I let Hugo use its default behaviour of generating url slugs from the file names. So even if the category slugs had changed (from /blog to /work or from /blog to /personal), the url slugs would stay the same. Which meant, I could whip up a script to run through all my markdown posts and add the alias line.
So I did.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


from pathlib import Path

INPUT_FOLDER = Path("old-posts-folder")
OUTPUT_FOLDER = Path("modified-posts-folder")

for each_file in INPUT_FOLDER.iterdir():
 with open(each_file, 'r') as file_to_read:
 alias_derived_from_file = each_file.stem
 contents_as_list = file_to_read.readlines()
 contents_as_list.insert(3, f"aliases: [\"/blog/{alias_derived_from_file}\"]\n")
 with open(Path(OUTPUT_FOLDER, each_file.name), 'w+') as file_to_write:
 file_to_write.writelines(contents_as_list)

It takes all the posts from my old folder, inserts the alias line and puts them into a new folder.² In essence, take each file, figure out the url slug from the file name, read in the contents as a list, insert my alias at position 3 (fourth actually. zero based indexing) of the list (below the title and date) and then write it all out to a new file.

I ran it, published the site and then went to check on the old urls with bated breath.
Hurrah, it all worked :)

Feedback on this post?
Mail me at feedback at this domain or [continue the discourse here][3].

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

it’s a list, so I can add more aliases if I want to ↩︎
no sense in botching up my originals :) ↩︎

anki-push-u, Creating a Tiny Pushover Addon for Anki

feedback@janusworx.com (Mario Jason Braganza) — Sat, 21 Sep 2024 11:31:39 +0530

I want to slowly increase my French vocabulary, so I got this comprehensive frequency word deck from Shared Decks section of the Anki website.

I keep forgetting to look it up during the day, after my morning session and the only way I can get those stubborn words¹ to stick in my mind, is if I keep doing the deck 4–5 times a day.

I know! With all my newfound devops/python skills, could I figure out a way to remind myself to do it? Turns out I can! :)

I already use Pushover, to get notified of darn near anything.²
And I read enough of Anki’s add-on documentation to know I could whip something up.
So a bit of searching on the net, a bit of jiggery pokery with Claude, and some spelunking through Anki’s source code and forums later, I present to you … anki-push-u!³

As long as your Anki’s running, this little add-on will find cards due, at the interval you tell it to, and then notify you wherever you have Pushover running!
No more forgetting due cards!

Find the add-on and instructions over at Github.

Feedback on this post? Mail me at feedback at this domain

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

I’m looking at you, ailleurs ↩︎
Hugo updates on three machines, calibre updates on two machines, podcast downloads and quite a bit else ↩︎
It pushes you to do your due cards! Tada! ↩︎

derb; Script to Create podcast RSS feeds

feedback@janusworx.com (Mario Jason Braganza) — Thu, 14 Sep 2023 17:38:03 +0530

I wrote a tiny script that creates an RSS feed for all the audio files it finds in a folder.
I call it derb.

My mother gets devotional songs and sermons on cds, which I rip to MP3 files and then dump on her phone for her.¹
She listens to them all the time, and now three of her friends want to do the same too.
I thought of just sticking them in my self hosted Jellyfin instance,² but then I realised, all of them have erratic, slow internet. So the idea of self hosting a podcast feed really appealed to me.

So I quickly used Feedgenerator in conjunction with Tinytag, to whip up a script that’d help me do just that. The code’s up on Github, if you want to go install and play with it yourselves.

Here’s a quick walk through derb.py.³

Setting up house
#

We set up a place to accept a path containing the files. The feed will ultimately be placed as a feed.xml in the same folder as well We then walk through the folder (after a really basic sanity check) and gather all the files into a list.
The base_url is where the feeds (along with the audio) will be served from.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


base_url = "https://ab.janusworx.com"

book_folder = input("Paste path to audiobook folder here: ")
book_out_path = base_url + (book_folder.split("/")[-1])
file_list = os.walk(book_folder)

# Do a basic check on the validity of the path we get, 
# before we build the audio file list.
try:
 all_files = (list(file_list)[0][2])
except IndexError as e:
 print(f"\n\n"
 f"---\n"
 f"ERROR!: {e}\n"
 f"Have you typed in the right path?\n"
 f"---\n")
 sys.exit("Quitting script!")
audio_files = []
for each_file in all_files:
 each_file = Path(each_file)
 if each_file.suffix in ['.mp3', '.m4a', '.m4b']:
 audio_files.append(str(each_file))
audio_files = sorted(audio_files)

Creating a feed
#

We now go about the business of setting up the feed proper.
To begin with, we grab the first file we can get our grubby paws on, and create a TinyTag object that’ll give us a lot of metadata. (If there isn’t any, we quit.)
Oh, and by the way, how do I know what data I’d need to create a feed? I just cribbed everything from the Feedgenerator’s excellent documentation. I also looked at the widely linked to, RSS reference page for clarification if I got confused.

We then, instantiate create a feedgenerator object along with the podcast extension.
Following which, we supply the feed a title, an id⁴, feed author details, a language, podcast category and description.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


# Setup a feed
## Grab feed metadata from the first audio file
feed_metadata_file = TinyTag.get(Path(book_folder, audio_files[0]))

## Grab title from metadata file.
## At the same time, break out if there isn’t any.
if not feed_metadata_file.album:
 sys.exit("\n---\nStopping feed creation.\n
		Setup audio file metadata with a tag editor")
feed_title = feed_metadata_file.album

## Creating feed instance
audio_book_feed = FeedGenerator()
audio_book_feed.load_extension("podcast")

## Setting up more stuff on the feed proper
audio_book_feed.id(base_url)
audio_book_feed.title(feed_title)
audio_book_feed.author({"name": "Jason Braganza", "email": "feedback@janusworx.com"})
audio_book_feed.link(href=f'{book_out_path}', rel='self')
audio_book_feed.language('en')
audio_book_feed.podcast.itunes_category('Private')
audio_book_feed.description(feed_title)

Adding episodes and writing out the file
#

After which it’s then a matter of looping through that audio file list we created and adding them as entries to the feed object we created.
Once again we grab the metadata from each file, using Tinytag, and then set each feed entry’s details (title, id and enclosure).
I’ve hardcoded the mime types, since I know I only have two basic type of audio files. If you don’t know what kind of audio, you might be serving, the mimetypes-magic package should help.
Finally we write it all out to a file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# Loop the file list and create entries in the feed

for each_file in audio_files:
 each_file_metadata = TinyTag.get(Path(book_folder, each_file))
 episode_file_path = Path(each_file)
 episode_suffix = episode_file_path.suffix
 episode_mime_type = 'audio/mpeg' if episode_suffix == '.mp3' else 'audio/x-m4a'
 episode_title = each_file_metadata.title
 episode_size = str(each_file_metadata.filesize)
 episode_link = f"{book_out_path}/{each_file}"
 
	audio_episode = audio_book_feed.add_entry()
 audio_episode.title(episode_title)
 audio_episode.id(episode_link)
 audio_episode.enclosure(episode_link, episode_size, episode_mime_type)

# Write the rss feed to the same folder as the source audio files
audio_book_feed.rss_file(f"{book_folder}/feed.xml")

Serving
#

Once done, I moved it all to my trusty Pi, which runs barebones Nginx with a single bare page, protected by basic auth.

I decided not to publish the feeds publicly.
Rather I’m going to just set it up in their podcast players, when I meet them, or pass it over to their kids over Signal.⁵
It’s already worked with three of them, so everyone’s happy and here’s me hoping, fingers crossed, it’ll be easy to support in the long run.

Update (2023-09-15): Guess I’m using it for myself too, now 😂

Feedback on this post? Mail me at feedback@janusworx.com

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

Yes, while it’s slowly moving to Youtube, that world still mostly depends on CDs and USB sticks. ↩︎
the audio files, not my mother’s friends. ↩︎
Large parts are elided. Please look at Github for the actual file. ↩︎
normally, the site it’ll be served from ↩︎
Why should I be the only one doing family tech support? ↩︎

TIL: The Difference Between a CLI Tool and a Freeze Tool

feedback@janusworx.com (Mario Jason Braganza) — Wed, 01 Mar 2023 11:35:47 +0530

I keep writing these tiny utilities for myself in Python and while I love writing in Python, I definitely don’t enjoy the little war dance I have to do everytime I want to run it on a new machine. Keeping track of virtual environments, and then installing packages in them, quickly gets tiresome. I want to just run the program once I’m done with it. Like a C program. Or Rust. Or Go.

I could go learn one of those languages. Sure. That’s an option.
And I see no problem doing it for other needs (like if I’m working with a group that uses said language) or for my career’s sake or just for being a polyglot.

But when I write for myself, I’d rather stick to Python.
Its mental model fits my brain. I find writing Python joyful.

So what’s a boy to do?
Since I was writing CLI applications, I went and looked for how to write Python CLIs and I found argparse and Typer and Click and I was confused. They didn’t seem to give me my executable. They had all sorts of other powerful features, but the one I wanted.
And I went looking some more. And the penny dropped.

What I wanted, wasn’t a way to build a CLI, (although that is what I was writing).
What I wanted, was a way to bundle my environment into an executable.
What I wanted, I learned, was a way to freeze my code.

More searching led to Nuitka, PyOxidizer, PyInstaller and their ilk.
I went with Nuitka, because that is what I found first and what I found was dead simple

python -m nuitka --static-libpython=no mastodon-to-moi.py

and boom!
I got myself an executable mastodon-to-moi.bin!
And then I got greedy and did a mastodon-to-moi.bin --help and figured, that’s where the cli/tui frameworks like Typer and Textualize, come in handy. To scaffold and help these interfaces.

But when I ran it on my laptop, which has nothing other than system Python, it hiccoughed. I tried Pyinstaller next, and that too, did not do the trick. It choked on a loop, that worked when I ran it as with Python normally. PyOxidizer scared me off.

This needs looking further looking into, but atleast I know what I need to do now

Afterthought: The one con I do see, is losing platform independence. My binaries will be Linux on Intel only.¹ I could just take my Python source anywhere, set up my environment and go. Well, I still have that option if I need it and in the meanwhile, having binaries affords me a lot of convenience.

until I learn to cross compile that is. ↩︎

What I Learned Today (8th of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Wed, 08 Feb 2023 20:20:06 +0530

Don’t know if it’s the gym or the regular work beat, but I seem to be waking up later and later everyday. I don’t know what to do about this. I feel a little anxious about not having enough hours in the day.

Python
#

Why use comprehensions? Because it reads better.
Like I advice the young ones in DPGLUG on writing.
Write short, choppy sentences.
They read better.
With my problem sets …
- I should stop trying to generalise in advance and solve the specific problem first.
- Read stuff carefully. Don’t do more than is necessary
- Solutions take time to understand too. Budget the time

Linux Mint
#

Nemo, the file browser in Linux Mint always opens the home directory, when I click on it and there’s no apparent way to change it to a preferred directory. I want it to always open Downloads

~~A little bit of web spelunking led to an acceptable work-around.~~
1. Change the command form nemo %U to nemo Downloads
  And that does it!

Update
#

2023-02-09: Does not work. Will look for some other approach. Right now, with the workaround it opens a Downloads window alongside any other folder I click on 😂

Hugo
#

Added a plain, hamburger menu to this blog, using Aditya’s helpful instructions over on the PaperMod Discord.
With all the extra nav items, I’ve added to the header the menu would overflow on my iPhone (and probably on other folks’ phones too). So if this page scooches narrow enough, it will change the links on top to a plain menu.

Huginn / RSS
#

I often have sites that have no RSS feeds, but they’re still interesting enough to me that I want to keep tabs on them for anything new.
While I wrote a tiny program to scrape and generate a custom RSS feed to get my Poetry fix, I needed something more robust, if I wanted to do this with lots of sites.
I realised that my Huggin instance could do that for me. Huginn is documented pretty well, that even a slowpoke like me, could figure out a fix for himself, inside an hour
I also learnt something fun. How do I choose a specific, nested, div on the page when all of them are similarly named? By using the power of XPath! I found it to be a more robust way of picking something from a web page, compared to its alternatives.
It’s also pretty easy to at least get a basic XPath selection. Just inspect your element in your browser’s web inspector and a right/context click should normally give you the option to copy a link as an XPath. Getting to an href link in the div I wanted, led to something like /html/body/div[1]/div[1]/div/div/div/main/div/div[1]/div/header/h2/a/@href and BAM! I got the link!
This solves a really big problem for me. So once again, I’m pretty chuffed today as well :)

Urdu
#

Got done with the “siin” group of letters today.
It is getting more and more confusing to read, but I’m sure I’ll slowly get over it with practice.

Physical Fitness
#

More Cardio today
I’ve gotten comfortable doing an hour of active cardio at around 160, without worrying that my heart would burst. Now to focus on doing the same hour at a slower heart rate, over time.
The pain’s almost gone. Let’s see what the coming days hold.

What I Learned Today (7th of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Tue, 07 Feb 2023 19:02:53 +0530

Yesterday, took a lot out of me.
Took it easy today.

Python
#

Got today’s assignment done well in time; and then went out looking for better ways to write it over again.
Writing code is getting exciting now. Just like how I learnt to write in my teens.
Write. And then go figure out, how I’d do it better.

Busywork
#

Spent a coupla hours doing some busywork for A Thing; that if it pans out will be a good thing for me.

Urdu
#

Did “chhoTii ye”, “ba.Dii ye” and “chhoTii he”.
Aamozish says, I’m done with the alphabet.¹
Pretty chuffed with myself :)

Physical Fitness
#

Did an hour of cardio today.
My body seems to have gotten over the hump of all that pain.
Hoping I’m not speaking too soon, though.
If this keeps up, getting weight training to be a habit will get easier.

with the exception of a few, infrequently used sounds ↩︎

What I Learned Today (6th of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Mon, 06 Feb 2023 19:31:33 +0530

Everything went to hell in a handbasket today.
Time was short.
I got up late.
I forgot, I had physio.
So most things got slightly abbreviated or dropped.

Python
#

Did not complete my assignment.
Flunked it again.
But on the plus side, those 45 minutes were some of the hardest thinking and iterating, I have done in weeks. So there’s that.
And on the plusser¹ side, I am proud of having stopped and then looked for help.
That was my biggest learning for the day.

Hugo
#

I need to write about what I actually did in another post.
But I created a custom Table of Contents for my Reading page, by hacking my theme’s template and layout. It was fun.
Long story short, the theme has the ability to create a table of contents by reading all the headers elements in the page. I restricted it to just the H1 and H2 elements.²

Urdu
#

Did the “vaao” group of letters today

Physical Fitness
#

Did gym and basic physio for my back.
Wiped out!

Yes, that is the technical term for even more ↩︎
It would have gotten too unwieldy otherwise ↩︎

What I Learned Today (4th of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Sat, 04 Feb 2023 21:26:59 +0530

A week in! Woohoo!

Python
#

Exercised with dictionaries today.
Today was the first time, I could not solve my assignment, no matter what I tried.
Lessons learnt:
- Stick to a schedule and do hard stops, since Python is only a small part of what I want to learn
- Learn to quit sooner. I’m like a dog with a bone, when it comes to problems. This approach may have helped me in the past, but it hinders me a lot, when writing code.

Urdu
#

Did the ‘re’ group of letters
Exercised with the ‘re’ and ‘daal’ groups
I’m learning the alphabet, using the wonderful Aamozish website, in case you folks have been confused about what I was doing with the language.

Webdev
#

Watched Webhooks for Beginners
Sooner or later, I want to customise my dinky little Huginn instance to do a lot more.
This’ll come in handy then.

Physical Fitness
#

Today was the first day, gym felt a wee bit normal.
Hope this positive phase continues …

Thoughts
#

I seem to have got into a good work rhythm.
Next step seems to prioritise my work and do more of what is needed, to get me a devops job.

What I Learned Today (3rd of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Fri, 03 Feb 2023 19:25:43 +0530

Slightly distracted day, today compared to the rest of the week before.
Well, c’est la vie.

Python
#

Read about functions, key functions, and asterisks
Practiced list comprehensions and dictionary lookups
Learnt and practised some, about decimals and rounding up

Devops
#

Devops-ish? Upgraded the BIOS of my desktop to the current the latest available version. I was on v1.5, when I had last done it in July ’21. Now I am on v1.9 from November last year. Fixes plenty of vulnerabilities.
While I got to know of it last eve, I did not upgrade then, because I wanted my mind fresh and attentive while I did this. I have bricked enough PCs and handhelds in my misspent youth and I cannot risk killing my daily driver to tiredness.
What do they call it now? UEFI firmware?¹

Urdu
#

Learnt the ‘daal’ group of letters
Today was also the first day, I realised reading right to left is becoming intuitive.
I read “Daataa”² in Urdu and went to check if I was correct by trying to read the English, and was wondering why they nonsensically called it “aataad”, until my brain switched back to Latin and reading left to right 😂

Physical Activity
#

I hope gym gets easier, because I am getting crankier about the pain by the day.
The better half says I sustained much more pain with physio and bore it longer and more stoically when I broke my back in 2017. Well, that was my body doing it to me and I had no control over it. Right now, I am doing this to myself, ergo the crankiness. I know this is good for me in the long run. Does not stop me from hating the process and its repercussions right now. I’m getting old and grumpy.

Dell seems to be old fashioned like me. They still call it the BIOS. ↩︎
God ↩︎

What I Learned Today (2nd of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Thu, 02 Feb 2023 19:30:55 +0530

Long day today¹. I thought I got nothing much done, until I wrote this post.
So, more incentive to keep writing these.

Python
#

Learning about how to make keyword arguments stick.
And how to think about structuring programs

Devops
#

Deep dive into how to add prow job listings to the dashboard and viceversa; how to go about looking for the job from the dashboard

Urdu / French
#

Lots of practice with vowels and the ‘jiim’ group of letters. Since I know Hindi, Urdu progress is much, much, much faster than French. I think that is because, I am forcing my English grammar / vocabulary on another Romance language that has Germanic influences. This is leading to a lot of cognitive dissonance and slow progress.
Much of my Urdu vocabulary comes from Hindi, which I learnt as a kid, and I definitely did not go looking for the “right” way to speak it. Better to just do French similarly as well. While I cannot do immersion, I can do what I want to do with French. Begin reading what I want to. Whether I understand it or not. I realise this will take me a lot longer than Urdu or Hindi, but that’s ok. Émilie du Châtelet, Montaigne and Dumas are not going anywhere, and neither am I :)
My frame of learning now, after doing these two languages, as well as the rest of the stuff I am doing, is to just begin doing². And figure out / learn the rules, the grammar, the conventions as you go.

Physical Activity
#

They call it chest and arm day. I presume, the exercises are meant to strengthen them. Right now, it’s just a stiff, painful mess.
I cannot wait for this phase to be over.

Books / Reading
#

Finished reading, The Boy, the Mole, the Fox and the Horse by Charlie Mackesy. It’s a hauntingly, beautiful book. A spiritual successor to the Little Prince and a Lindy book for sure.

I hate the gym ↩︎
Priyanka, Pradhvan, Rahul and Kushal be like, We told you so! ↩︎

What I Learned Today (1st of February, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Wed, 01 Feb 2023 19:25:30 +0530

Did a full day.
But is this sustainable?
I’ll know in a week or so.

Python
#

Finally figured out what def __init__ (self): does in an class, in a way that makes sense to my mind.
If I create an class and I want it (i.e. the objects created with it) to take in arguments, then I need to define an __init__ method to set it all up.
For e.g. if the class definition is just class chantSomeName(): where do I reconcile the fact that I need to pass in a name that needs chanting? In its __init__ method

class chantSomeName():
 def __init__(self, name):
 self.name = name

Python does a lot for me. My first approach going into any problem should henceforth be,
- Does Python already do this for me already, natively?
- I should think of Python less, as a forge where I make my own tools (which it undoubtedly is) and more as a librarian, where I can just ask it for something and it will return it to me. The more I study it, the more I realise just how much it keeps track of and how much it tries to make life easy for me

Devops
#

Learnt a bit about how Prow jobs work

English
#

Learnt a new (old) word
- viscid
Vis"cid (?), a. [L. viscidus, fr. viscum the mistletoe, birdlime made from the berries of the mistletoe; akin to Gr. ?: cf. F. viscide.] Sticking or adhering, and having a ropy or glutinous consistency; viscous; glutinous; sticky; tenacious; clammy; as, turpentine, tar, gums, etc., are more or less viscid.

Urdu
#

Working my way through the alphabet. Did the jeem group of letters today

Physical Activity
#

An hours worth of cardio. I am really gritting my teeth and hoping all of this pain, pays off.

Django
#

Learnt how to docker-ise my tiny Django app, that I’m writing, so I can have a contact form on the website.

What I Learned Today (31st of January, 2023)

feedback@janusworx.com (Mario Jason Braganza) — Tue, 31 Jan 2023 21:10:12 +0530

Been knocked down a little too much over the past few months.
This is me, getting up from my knees.

Doing some things daily to learn.
To give myself grace
To be kind to my self.

Python Morsels
#

Getting back into the swing of writing code.
Today was basically just looking at a blank screen and wondering why nothing would come out.

Urdu
#

Started with module one of Rekhta’s wonderful Aamozish.
I hope to have read at least one Urdu book by the end of the year.

Physical Activity
#

Went to the gym. Worked with a kindly trainer, who understands my pain and then keeps telling me about all the good things “one”¹ needs to do. I have no legs.²
I hope I get used to this soon.

Devops
#

Worked with a colleague. Trying to create a presentation.

French
#

This is something I barely spend 5 minutes on.
But I do it daily.
The only reason I mention it here, because today is Day 100 of showing up.

There is no “one”. It’s all specific to me 😂 ↩︎
I do in fact, have legs. It’s just that the gym session killed me. Well, I am in fact alive. I am just prone to hyperbole. ↩︎

FOSS.training / DGPLUG Summer Training 2022 Begins

feedback@janusworx.com (Mario Jason Braganza) — Sun, 24 Jul 2022 12:35:43 +0530

Let’s get the important bits out of the way first.
I have been both, busy and lazy. Mea culpa.
But the new FOSS.training’s aka DGPLUG Summer Training cohort begins tomorrow, the 25th of July, 2022 (6.30pm IST). Come, join!

Join the mailing list, here.
Come join the #dgplug irc channel on Libera, because that’s where the training will be conducted.

So, what is it?
#

The summer training is short-ish, couple of months-ish long, series of meetups on irc.¹
Mentors come. Students gather. A cohort forms.
And we learn all about the free and open source world.
If you’re a young person, looking to learn the culture and the tacit knowledge of how the free and open source or someone older or if you feel like someone who is on the outside looking in, all are welcome.

From learning tactical things like communication skills, or basic programming to the more important things like, the importance of our culture, we aim to communicate all of this, so that you get a good grounding in becoming an open source contributer.

This year, will be our 15th cohort.
And folks from all walks of life have come and better their lives and gained opportunities thanks to the skills they’ve learnt.
Even more important though, are the people you will meet on this journey and the friendships you will make.
Pradhvan, Farhaan, Bhavin, Nabarun, Sayan, Trishna, Chandan, Kushal, Anwesha, and Priyanka are all friends, I have made here.²
You could be next friend I make :)

Anwesha has more about past attendees and the mentor’s posts in her announcement post.
Kushal has been writing about his journey through these years on his blog.
Read more about the training on the main website.
And if you decide to take the plunge, here’s a good before you start guide.

Hope to see you all there!
And oh, here’s to the places we will go!

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

All the -ish’s are because, the training in fact never ends. We hang around and keep learning. ↩︎
and lots more. Apologies to all the people, I haven’t listed here :) ↩︎

Updated Poemfeed

feedback@janusworx.com (Mario Jason Braganza) — Fri, 27 May 2022 18:52:00 +0530

Update: fixed Github link

The little script I wrote in 2020, to get me my daily poetry fix, died a couple of months ago.
Life got in the way of me, figuring out what was wrong.

I finally got around to it today.
A little bit of peeking under the hood revealed that Cloudflare did not like me using the Python Requests library to check the Poetry Foundation page.
Or maybe it just did not like the useragent string that Requests gave it.
I was in no mood to go down that rabbit hole, so I just went looking for modern alternatives to Requests.
Found HTTPX.¹ and switched over to it.²
And then while I was at it, replaced PyRSS2Gen with FeedGenerator.

And tada! Poemfeed lives again!
Find the updated code, over on Github.

Writing code today, made me realise, how far I have come since I wrote that code.
I figured out the issue, I knew just how I wanted it to work, I went out, researched the code, and then wrote and iterated over the code and got it working in a matter of hours.
Kushal was right.
Writing lots of shitty code, over and over and over again is the best way to get fluent.
Here’s to more contributing and lots more of writing code!

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

which delightfully, has a Requests compatible API ↩︎
and to be sure, changed the userstring, so that my script presented itself as Firefox ↩︎

Installing PyCLD3 on an Apple M1 Mac

feedback@janusworx.com (Mario Jason Braganza) — Wed, 30 Mar 2022 09:33:39 +0530

While building my work product on the fancy-schmancy M1 work Mac, I kept running into clang errors, when I did a pip install
Turns out, PyCLD3 would not build.
So I did it manually. This tip on Github did the trick
We need brew installed.
And then we run the following commands in a terminal …

 
brew install protobuf #install protobuf

# set various compiler flags
export GRPC_PYTHON_BUILD_SYSTEM_OPENSSL=1
export GRPC_PYTHON_BUILD_SYSTEM_ZLIB=1
export CFLAGS='-I /opt/homebrew/opt/protobuf/include'
export LDFLAGS=-L/opt/homebrew/opt/protobuf/lib

# install pycld3
python3 -m pip install pycld3

And we’re set!

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

I’ve Joined Scrollstack

feedback@janusworx.com (Mario Jason Braganza) — Tue, 16 Nov 2021 11:09:28 +0530

I’ve been job hunting for nearly a year and I was resigned to the vagaries of the interview process.
Close to 16 interviews later, I was inured to every possible rejection note under the sun.

We don’t quite know what to do with you.
You’re too slow.
It’s us, not you.
The position just got filled.
While we don’t want you, we assure you, someone else will.

I understand it’s a process, that everyone goes through, but I somehow still held hope that someone would inject some humanity into what seems to be a pretty inhumane process.
And Scrollstack was exactly it.
While I still haven’t asked the powers that be, why I got in, their process of treating people humanely is what attracted me to them.
They wanted me on, and I’ve joined up as a Software Developer.

And ofcourse, would a guy who loves writing, love to help build tools that helps folk write? And earn, while we’re at it?
Does a bear shit in the woods?
Hell, yeah!

Here’s to upwards and onwards!
And Scrollstack, you have my undying gratitude for helping me start a new phase of my career.

P.S. Subscribe to my mailing list!
Forward these posts and letters to your friends and get them to subscribe!
P.P.S. Feed my insatiable reading habit.

To my Teachers, With Gratitude

feedback@janusworx.com (Mario Jason Braganza) — Wed, 27 Oct 2021 16:00:00 +0530

Shoutouts of Gratitude to the teachers who I learnt programming from over the past couple of years …

Kushal Das, for bringing me in, teaching me the ropes and assuring me there was a place for me here

Reuven Lerner, who unravelled Python for me and made me realise that languages were small, and the reason I was struggling was not Python, but because I wanted to understand all of computer science in too short a time frame.¹

David Malan and Brian Yu for the grounding that is CS50.

Dr. Chuck (Charles Severance) for opening my eyes to the wonder that is web programming.
And databases, and Postgresql.
And Django.
And so much more!
You taught me how the pieces fit.

Julia Evans for showing me that being good at sharing knowledge, is not magic, just a lot of hard work and dedication.
And for teaching me oh so much, with your magical zines.

Mark Lutz for his exhaustive, thorough books on Python.

Damian Conway for making regexes make sense.²

Barbara Oakley, for teaching an old dog how to learn.

Cal Newport and Scott Young for helping me put it into practice (deliberately 😂)

Brad Traversy, while he may not have melted my mind, he is the embodiment of everything i learnt from the teachers above. Patient, humble, transparent, persistent, all round hero.

And last, but certainly not least, my young friend and mentee, Priyanka Saggu, for teaching me dogged persistence and for being an unabashed cheerleader on my journey.

All of this to say, good teachers are hard to find, and are worth their weight in gold. For every teacher on the list above, I failed with at least 5 more.

If you ever feel dumb, despite doing your best, like I constantly did, maybe it’s just the fact that the teacher and you are not compatible. The way they teach, might not be the way you understand

Which is why, if you are privileged enough to do so (or are willing to put in the time and the effort), there is no shame in looking for a ‘better’ teacher. No worries in doing the work of finding that someone who can make stuff go ‘click’ in your mind; who can make the world make better sense to you

My experience has been that such folk are hard to find, and when you do luck across gems (like the people above) make sure they know it.
Be grateful that life has brought you to them.
And make sure you learn all you can, to the best of your ability.

Reuven’s courses are worth it, for the groan worthy puns alone. ↩︎
Something that I’ve wanted to do since the 90s ↩︎

Learning Backend WebDev, Log #1

feedback@janusworx.com (Mario Jason Braganza) — Mon, 07 Jun 2021 19:33:46 +0530

test

A Day of Updates

feedback@janusworx.com (Mario Jason Braganza) — Mon, 16 Nov 2020 18:08:36 +0530

Could not focus much on programming today.
So decided on doing things with Python programs.

Nikola Upgrade
#

I use Nikola to generate both my websites.
It is an extremely easy to use, no fuss static site generator, which is easy on my server’s resources.
Version 8.1.2 was released a few hours ago and I hopped on and installed it.
I follow a slightly unconventional upgrade path, because I was terrified of breaking my server in the early days, when I was still learning about how to go about installing things on servers.

I have Miniconda installed.
I use that to generate a conda environment, which I then installed Nikola into.
When a new release drops, I create a new conda environment, install the new release in there and run them against my source folders (after backing them up).
This lets me revert very quickly to the old data and the older version of Nikola, in case I do something boneheaded and screw things up.
If all works fine for a month, I delete the older conda environment along with the old Nikola release.
I have been doing this for quite a while now, and while it may be overkill, it gives me peace of mind.
As usual, Nikola upgraded with no issues at all.

Pleroma Bot
#

I always wanted to understand what bots do.
Now I realise they are athromorphic programs that (with the right permissions and the right credentials) look like actual users of a service, doing sets of activities they are programmed to do.
Like your banking app has set of solutions to common queries that it shows you, before it hands off to an actual human, if those solutions don’t fit your needs.
They feel like supercharged scripts to me.
So I decided to see if I could install one.
Since I am learning Python, I love reading the low volume Daily Python Tip Twitter account.
It has surprising, handy, funny, interesting tips and tricks about the Python language and the massive ecosystem around it.
But, I have weaned myself off Twitter for my own sanity.
I only use it sparingly once a day.
And going back to that noise and tumult no longer interests me.
I saw a bot that mirrored tech news accounts to Mastodon and wondered if a bot could get Daily Python Tip to me on my Pleroma timeline.
A quick search led me to Pleroma Bot.
A couple of struggling hours later, (creating a twitter developer account, creating a pleroma account for the bot, figuring out how to get bearer tokens for said accounts) and tada, I got the bot to come alive!
It checks the Twitter account once a day, and mirrors the tweets to the bot account.
You’re most welcome to follow it for a Python tip, daily.
The next thing to do, is to see if I can get a bot to post a tagged pleroma status to my twitter account.
But that is something for another day …
Update, 2020/11/17: figured out how to use the bot to mirror multiple accounts. It now mirrors, Daily Python Tip, RegexTip, and CompSciFact.

Git the Branch

feedback@janusworx.com (Mario Jason Braganza) — Fri, 13 Nov 2020 18:55:00 +0530

I started playing with a way to control Git via Python.
Kushal had asked me to write a program, that would show me the local git branches.
So here it is!
I call it Git the Branch. (painfully, punny, I know :))

And now I realise why he asked me to do this.
The program itself is trivial.
Here’s the code on my code repo, Gitlab, and Github.
It just consists of me using GitPython to access the current folder via a GitPython Repo object.
And then querying it for its branches.

The important work was done yesterday, when I pored over the documentation and figured out how GitPython actually works.
And I realised that is what Kushal wanted me to do.
Read something and figure out how I could adapt it to my situation.

The other thing I realised, was licensing.
I want my programs to be used, played with and adapted.
So it makes sense for me, to make it as easy to use as possible.
This is why I have decided, that until circumstances dictate otherwise, I shall use the MIT License.
This led me to check if I could then actually license my software as such, if the software that I depend on (in this case GitPython) have different licenses.
My arbitrary and random research suggests that I can do so.
If I learn otherwise, I shall think about what to do next.
If you have anything to suggest, please let me know, by mailing me at jason at this domain.

One other (painful) thing, that I realised is that I cannot focus at all when I am writing code.
This post has come out in a blur of focussed writing.
My academic studies are also something that I can focus for hours on.
Apparently that focus does not translate to programming.
I need to build up this skill for this domain seperately.
Hopefully, this will come with showing up daily.

This was fun to do.
Here’s to writing my way to fluency.

P.S. Subscribe to my mailing list!
P.P.S. Feed my insatiable reading habit.

P.P.P.S. Update, 7pm the same day, The answer to focus, lies in this serendipitous Seth post

A third might be, just for an hour, to turn it off.
All of it.
To sit alone and create the new thing, the thing worth seeking out, the thing that will cause a positive change.

I love it when the universe speaks to me :)

Poem Feed

feedback@janusworx.com (Mario Jason Braganza) — Fri, 13 Nov 2020 17:00:00 +0530

Update, 2020/11/13: This has been working beautifully! I love the poems as they show up in my feed.

This is a tiny little niche thing, I built all for my ownsome.
It all started, when I got hooked on reading the daily poem, on the Poetry Foundation page.

Learning Python as I am, I wondered if there was a way to have it come to my RSS reader.
And so Poemfeed is a tiny little utility that does just that for me.

It looks up Poetry Foundation’s, Poem of the Day for a new poem.
If there is one, it follows the link to the complete poem, and then gets the link to that page and writes that into an simple RSS entry in an xml file.

I then wrote a simple cron job that executes the python script twice a day, and if an xml file is generated, it moves it to a place that my RSS reader can access.
Et voilà, a brand new poem everyday! (or as often as they publish :))

The code’s here, on my repo, on Gitlab and on Github, if you want to have a look see.

Starting Work on Git-the-Branch

feedback@janusworx.com (Mario Jason Braganza) — Thu, 12 Nov 2020 15:16:12 +0530

The Itch
#

Aiming to write a tool using this which will show all the git branches in the current directory and the last commit date on those branches (and only the local branches :))

What I did today
#

I had to carry my phone in to the service centre, so I did not quite have as much focussed time as yesterday, with all the coordinating and carrying, but I learned a few new things

Kushal hinted that I could use GitPython to do what I want.
So I spent a little while reading there.
And then decided to test it out.

And then immediately went yak shaving, because I wanted to solve the problem of how to quickly type iterate in Visual Studio Code.
I learnt lots of Python using Reuven Lerner’s courses and I used a lot of Jupyter Notebooks then.
And I love them.
The trick now, is to figure out how to use them in Visual Studio Code.
To my delight, the Python extension in VS Code has support for notebooks. And all works well for the most part.
The only thing that tripped me up was that when I tried importing a module in the notebook after activating my virtual environment, the Jupyter server hiccoughed and threw up some error about not finding the module (which I knew was definitely installed) and then something about it not being in the PYTHONPATH (which I had no clue of which places, it was looking in.)
A little snooping and I realised that the extension loads the server with a default kernel in someplace. And I need to tell it about my environment. Once I told it to use the kernel from my venv, all was fine.
VS Code went and installed a ton of things and found what was already there and everything was hunky dory.
A from git import Repo worked just fine.

I felt good about this piece of dawdling, because I know this is something I am going to do every day and better I spend some time figuring it out, right at the start.

I learnt that I could use the ! mark as a prefix in Jupyter to run shell commands! A !ls will show me the contents of my folder :)

I skimmed the GitPython documentation.
I kind of got what I want.
This will require lots more work, which I shall have to put in.
But even a cursory glance, showed me that GitPython was an exhaustive wrapper, that would let you do practically anything you would want to do with Git.

More tomorrow …

A Good First Day

feedback@janusworx.com (Mario Jason Braganza) — Wed, 11 Nov 2020 19:05:10 +0530

Was a really good day to ease back into Python today.
I got my VS Code up and running.
I got a personal [Gitea instance][crjw] up, to host my code, from where I will syndicate it to Github and Gitlab.
And finally I got a projects page up, to slowly fill up with projects.

I also managed to improve an old program I wrote for myself, but I’ll write about that in the next post.
All in all, a day well spent. A journey well begun.

Getting Back on the Horse

feedback@janusworx.com (Mario Jason Braganza) — Wed, 11 Nov 2020 09:49:28 +0530

Ok, one more time.
I know there have been lots of one more times before, but I am going to keep at this until I get proficient enough at this to land a job :)
And while I may not be brainy enough, the one thing I can do is be persistent enough to show up.

This time, I will focus on building tiny projects.
I realise my life is too chaotic for #100DaysofCode.
But I can do this, one tiny thing at a time.

Wish me luck!

A Hundred Days of Code, Day 026 - Refactoring

feedback@janusworx.com (Mario Jason Braganza) — Mon, 03 Aug 2020 13:00:03 +0530

Worked only an hour today.
Trying to change the little lookup program, I made the other day, into something a little better.

Not quite a good day.
Calling it quits early.

A Hundred Days of Code, Day 025 - Comprehension Exercises

feedback@janusworx.com (Mario Jason Braganza) — Mon, 03 Aug 2020 12:57:20 +0530

Working on Comprehension exercises today.

Reflections and Experience
#

I really need feedback, when it comes to programming. I cannot face a blank page. I always seem to start with printing something out to screen and then my brain kind of kicks into gear. Everything after that is just type, print, is this what I expected, if not then fix, type, print …
Exercise 3.1 and I think, I am finally getting good handle on comprehensions.
- from something that would take me at least 10 lines of code to just expressing it concisely in 1!
I can read Python messages and take a gander at what I need to do next.
- I see a '_io.TextIOWrapper' object and know I can iterate over it.
- I see AttributeError: '_io.TextIOWrapper' object has no attribute 'strip' and realise that it cannot be stripped into parts. I need another way to skin that cat.
And then I took it too far (just like this sentence), and nested a comprehension in another one, in where, I had to learn how to put in a conditional in the form of a ternary operator, in Exercise 3.2 (the commented for loop is much simpler!), but that was very good practice. Really stretched me!
I caught myself getting distracted a lot. I needed to set a 30 min timer and I spent about 15, looking for where the timer app in my Mint Desktop was, instead of just setting the darned timer on the phone.
Took an hour to figure out the comprehension for 3.2 and about 20 minutes to do it for Exercise 3.3. Practice helps!
Watching the solutions, and I realise, I got them right in principle, but that I need to be more aware of what happens to an object in memory, so that I can simplify code. I was able to remove one level of comprehension, which I used just to get the end of a string.

A Hundred Days of Code, Day 023, Day 24 - Tiny Utility to do comparative DNS Lookups

feedback@janusworx.com (Mario Jason Braganza) — Sat, 01 Aug 2020 15:33:22 +0530

Problem - Compare domain lookups, against DoH Servers
#

Take a list of domains (one per line) from a text file as input, find the IP address for the domain using the standard system level DNS, and then check against DoH answers from both cloudflare and google. and say if all answers match properly or not.

Notes
#

What do I need to do? (checklist)

Get a list of popular websites, (probably Alexa)
figure out a way to read them in
loop through each line, and look up its ip
- with the local dns (use the sockets module)
- with Google’s DoH json endpoint (use the requests module)
- with Cloudflare’s DoH json endpoint (ditto like Google)
Compare all the values.
Print if they match or not.

Experience
#

I should commit my work often. This took me two days, because I lost all of yesterday’s progress in a computer hiccough.
The program runs well. It intentionally limits itself to only the first result in the Google and Cloudflare lookups.
I should learn to focus more on what is at hand and not overthink the program.
I should be learning to build primitive little, handy dandy tools, not giant cathedrals.
I spent two hours fiddling with a way to create another program that would process files for me. (and abandoned it)
I need to read the documentation across sites very carefully.
- They are written with experienced programmers in mind, and not beginners like me.
- For e.g. When I was trying to look up domain names with Cloudflare, I blindly copied the example and then wondered why it was not giving me the appropriate replies. I then realised I was missing a seperate parameter, &ct=application/dns-json which was quite clearly listed above, but not in the example below. (which in truth was listed, but as part of the command at the command line and I, like a dumbass, just copied the requisite code to adapt to my Python program. Lesson: Cargo cult with extreme caution)
Which leads back to the fact, that I should stick to what is assigned, because just doing that much at this stage is taking me a long time. Improvements and features can wait until I am much more fluent.
I realise I am trusting autocomplete too much, and I should at least look at what I am completing. I spent 40 minutes, wondering why my comparisons were not working, when in fact, I was using the wrong variables.
Lost loads of time with typos.
Be more intentional. More slow.

Code.
#

Put your sitenames into a file called dumpsites.txt Run check-ip.py

Gitlab / Github

A Hundred Days of Code, Day 022 - Getting into the Groove

feedback@janusworx.com (Mario Jason Braganza) — Thu, 30 Jul 2020 12:03:45 +0530

Did the same time as yesterday.
Only about an hour.
Was much more prodcutive though.

Getting the hang of how to sit and program and work through things I do not know.
Gaining a bit of experience with the workflow now.
I have the basics in hand. I know what I want to look up.
So check problem, work a bit, look up, try, fail, repeat, gain incremental success, work some more.
Love the feedback loop too.
With other stuff I try, I have to wait days, weeks, months.
Here, it’s immediate.

Beginning to love the work, as I get more familiar with it.
Tomorrow is another day :)

A Hundred Days of Code, Day 021 - Swing and a miss

feedback@janusworx.com (Mario Jason Braganza) — Wed, 29 Jul 2020 18:06:35 +0530

Only did about an hour of distracted work and exercises today.
I’ll still count it though.

Tomorrow is another day :)

A Hundred Days of Code, Day 020 - Setting up an Editor for Python Development

feedback@janusworx.com (Mario Jason Braganza) — Tue, 28 Jul 2020 17:29:08 +0530

Had given myself a day, to see if I could get a good Python development environment using Elpy and Emacs.
It does work.
Just not well enough for me.
At the end of the day today, I was happy I learnt so much about Emacs.
But that is not my focus right now. Python is.
Emacs knowledge can come slowly and organically.

So I have kept Emacs as my regular editor for nearly everything text.
And switched to the community edition of Pycharm for all my Python projects.

I am also grateful to all of you, who gave me problems to practice on.
These will help me grow.

A Hundred Days of Code, Day 019 - Future Exercise Addendum

feedback@janusworx.com (Mario Jason Braganza) — Mon, 27 Jul 2020 16:23:14 +0530

Ok, think I have the problem of writing code, licked.
Will start with one problem from all the Lerner Courses, that I still have to do.
And another problem, I ask my friends to give me.

This should prove for a promising start.
If you, dear reader, have problems in Python that you’d like me, a budding Python programmer to solve, please mail them to me at jason at this domain.
It’ll add to my pool of problems and give me plenty to practice.

A Hundred Days of Code, Day 019 - Python Iterators and Generators, Done!

feedback@janusworx.com (Mario Jason Braganza) — Mon, 27 Jul 2020 11:55:48 +0530

Starting up with the last of the Lerner courses, I got.
Iterators and Generators.
Hopefully I get done with this and use the same intensity with actually writing code.
What shape will that take and how will I write about it? I have no clue
For now, notes follow.

Notes
#

** Part 1, Iterators **

If we run the iter function on something and it comes back with an iterator object, then it’s iterable; I can iterate on it.
Behind scenes in a for loop, Python does something similar. It asks if the object that has to be looped over is iterable with iter. And then keeps doing next with it to get the next result/item, until it comes across a StopIteration which lets it know, that the values are exhausted and it can stop looping.
The for loop is a very thin shell, that asks the appropriate questions of the iterator. But it is always the iterator that determines, what exactly is returned.
iterable vs iterator
- iterable means that it can be put into a “for” loop in Python
  - things like strings, lists, dictionaries, sets, files and objects (that I will soon create) that implement that iterator protocol.
  - it responds positively to the iter function’s question, Are you iterable? It returns an iterator object instead of raising errors (TypeErrors in this case)
- an iterator is the object returned by the iterable, the thing on which the next function is run.
  - it could be the original object (the iterable) itself.
  - it could also be a seperate object returned by the iterable.
  - when the iterator object is exhausted, it returns StopIteration
  - these are what give us the values.
How do I make my objects iterable?
- By implementing the iterator protocol
  - the object must respond to iter, by returning an iterator object
  - it should respond to the next function with values
  - it should raise a StopIteration error, when it’s done.
Best to create a helper class, pass the data to it and return that as the iterator instance.
- helps with state, since I can then use the same object and iterate over it multiple times independantly.

** Part 2, Generators **

Creating a whole class just to implement an iterator, might be overkill
Generators are a solution, that might come in handy.
They are like functions; functions that implement the iterator protocol.
instead of using return, we use yield.
- this lets us return multiple items.
I can use them to chunk large items, buffer uncertain stuff, and wrap complex stuff.
Rule of thumb,
- if I already have a class, just added functionality to it using an iterator class.
- but if I need something standalone, just use a generator function

** Part 3, Coroutines **

Little helper functions.
- With such a function, I assign the yield statment to a variable.
- This makes the function sit and wait for me to send it something.
- Once it receives data, it ingests it, processes it and poops out, yields an answer :)
- x = yield x
- Instead of sending data back to a coroutine with send, I could send it an exception using throw.
- I use close to close the generator and break out (trap GeneratorExit)
- I can just say yield from some_generator if I am calling another generator from my generator.

** Part 4, Generator Comprehensions **

Create one just using () genvar = (x*x for x in range(-5,5)) will make genvar a generator object.
The general idea, I am getting, behind the idea of generators and iterators is that we use them on really large objects, so that we don’t run out of memory.
- for e.g. joining a list of 3 elements is easy-peasy. A list of 3 billion elements less so, and ergo, generators and iterators.
- the ultimate idea being, just like an oil pipeline. We ought not to store it in tanks (lists, dictionaries etc.) We ought to strive as much as possible that it flows from upstream, right through to our taps in a single unbroken stream. Just pass the oil along, using various t-junctions and pipes and motors and stuff. Keep it flowing. Minimise storage.
- it also spreads wait times across well, time. So I never have to wait for something to gather up and collect and then display. the generator comes back instantly and when it has to get a values, I just have to wait for that one value.

** Part 5, itertools **

itertools is a collection of generators/iterators, that’ll let me add the iterator protocol to existing classes and functions. Looking through these feels like looking at specialty carpentry tools, like this biscuit joiner.
lets me take advantage of other smarter folks’ work and optimisations
- itertools.chain crawls elements across iterables
- itertools.count counts upwards from a number given, in steps if we want.
- itertools.cycle cycles through a range of options
- itertools.repeat repeats a value for the number of times, we tell it
- itertools.filterfalse takes a iterable and a function, applies the function to the iterable and if the function returns false, only then is the element from the iterable, passed through. (the inverse in which only true elements are returned is a built-in in Python, aptly called filter)
- itertools.takewhile and itertools.dropwhile are opposites of each other
  - takewhile takes a function and a sequence, applies the function to the sequence (starts a while loop) and then immediately stops if it hits false
  - dropwhile inverts that. it starts a while loop when it hits it’s first false and then keeps going from there.
- itertools.compress takes two iterables of equal length, (or if they are unequal, it’ll stop when it reaches the end of the shorter one) and then if the element second iterable rings true, it returns the element in the first one.
- itertools.accumulate adds the first element to the second element, then adds that the third element and so on. (if i want to use some other function of add, I can do that too)
- itertools.tee lets me create multiple instances of a generator, each with it’s own state (memory intensive.)
- permutations and combinations
  - itertools.product takes an element from one iterable, runs it across all the elements of the second (or third and fourth) and returns a cartesian product, an x,y (or x,y,z) coordinate tuple.
  - itertools.permutations does permutations across two iterables. returns tuples.
  - itertools.combinations does combinations.
  - itertools.combinations_with_replacements does combinations allowing each element to repeat. (a combination might not allow (10, 10, 10) for example; this helps with that)
- more-itertools is an external package that gives me more complex itertools. (pip install more-itertools) need to look at them later.

Learning / Feedback/ Experiences from doing exercises
#

Reuven tells stories “Deep in the recesses of Python …”
Reuven’s talking Python interpreter, “Hey Object, are you iterable?”
I am slowly anticipating the problems in Reuven’s code as he keeps iterating on them.
- ‘Will this work?’, asks Reuven.
  ‘NO!’, I yell back at the screen. ‘This function does not do anything, will return None and cause an error!’
  I am learning! This is fun! :)
Been going, “Ooooh! So that’s how they do it!” lots of times in this class.
Ok, have now dropped from a 30,000 foot view of Python to a 10,000 foot view. Will hit ground level, starting tomorrow, when I start doing exercises.

Read all about my Python Iterators & Generators journey here

A Hundred Days of Code, Day 018 - Python Comprehensions, Done!

feedback@janusworx.com (Mario Jason Braganza) — Sun, 26 Jul 2020 19:00:00 +0530

Continuing my comprehensions journey.
Hopefully it makes more sense this time around

Notes
#

** Set Comprehensions **

If I want a set of uniques from a group, I could use a set.
- Or like Reuven likes to joke, a set is a dictionary with no values; an immoral dictionary 😂
Create it with a somesetcomp = set('somecondition' for a something in somethingbig) or in a simpler manner, somesetcomp = {'somecondition' for something in somethingbig}
- Protip, better to start with a list comprehension, be done with figuring out stuff and then just switch the brackets at the end. Fewer issues that way.

** Dictionary Comprehensions **

Create it like so somedictcomp = {somekey:somevalue for something in somethingbig}
It creates only one dictionary, not a set
It has to have a key and a value variable, seperated by a colon. If it is just a single variable, I’ll end up with a set comprehension.

** Nested Comprehensions **

Running a comprehension on the elements of a parent comphrehension is a nested comprehension.
- For e.g. if I had a list of lists and I needed to pull out each element from each list I would
  - create a comprehension that would get each list from my giant list of lists
  - and then run a comprehension on those lists to get each element out.
  - big_list = [[10, 20], [30, 40], [50, 60], [70, 80]]
  - elemental_list = [each_element for each_list in big_list for each_element in each_list]
Pretty handy when needed. I can go as many levels deep as needed.

** Why Comprehensions? **

A comprehension is needed or rather the better tool for the job, when I have one sequence and I want to turn it into another sequence. Creating new things from old things
If I am interested in the side effects, the actions, umm, like printing to the screen for example, that is when I’d use for loops.
It gets increasingly obvious, the more I use it.

Read all about my Python Comprehensions journey here

A Hundred Days of Code, Day 017 - Python, Advanced Objects, Done!

feedback@janusworx.com (Mario Jason Braganza) — Sat, 25 Jul 2020 18:10:46 +0530

And we are done with objects!
This course finally gave me what I was looking for all these months.
The ability to think of and reason about Python, so that I can then think of and reason about, how to build my own programs.

Notes
#

Abstract base classes
- Sounds all high and mighty, but does something pretty logical and simple
- Helps me test if my object is of a generic (of sorts) type. I don’t want to test if 5 is an integer or a float or any of the other various county types in Python. I just want to see if it’s a number, of some sort. The abstract base class numbers helps me do that.
- There are such classes for strings and files, I hear.
- Will go into learning more about them in detail later, as I actually write more Python. But at least I know what they are now.

** Part 3, Context Managers**

Again, Context Managers, sound like something really complex, but they are just a matter of writing and doing things in a certain manner.

It’s something like a Tiny Habit stack loop, I learnt in the Atomic Habits book, as I was building up new habits.
- When I do this,
- then I will do this immediately after.
- and when I am done, I will do that.
Context Managers have a similar paradigm.
- With this object (as this variable, optionally)
  - I will run the __enter__ method
  - then after, I will do stuff
  - and when I am done, I will run the __exit__ method
- I can add the context manager protocol to my objects too, by impletementing the __enter__ and __exit__ methods in my classes
- They are used in a particular context, where you want to turn something on and then turn something off, before and after that context, thus Context Manager.
  - I can set something up in my __enter__ method and then tear it down in my __exit__ method.
  - This could be, for example, a network connection, a file, a redefinition of some sort, etc.
  - The __enter__ method must return self if all has to work well.
  - The __exit__ block, takes four arguments, one for self, one for an error class, one for the object, and one for the address in memory, the traceback. I can use them to catch errors in the main body of my with block, and then decide what the appropriate way to deal with them is.
  - A good example is using redirecting the print function’s output to a file, using a context manager. (The print function can write to a file, when I specify it as an output device like so print ("Hello there", file=f)
  - While I might be able to catch errors in the body of the context manager, I cannot if something happens during __enter__. just something to be aware of.
Contextlib is a library of context managers, Python already provides us.
- import contextlib
- contextlib.redirect_stdout/err will redirect stuff from the default output (the screen) to whereever else you want it to.

** Part 4, Properties and Descriptors **

A property is an attribute, that acts like getters/setters in other languages. It uses methods to set other attributes in the class (within the bounds we set). For e.g. a .temp property that will let you set temperatures, but only in the range you specify. not below 18C and not above 25C.
set by putting @property atop a getter function (let’s say temp) and then defining the setter properties in an identically named temp function again but decorated with @function_name.setter; in our case @temp.setter
the whole actual way to do it is like a contortionist twisting into a pretzel shape. Getting fluent with this will take time and practice.
it basically (to my mind) is like me giving someone something, and that someone goes and magician like, does something marvellous with that something, instead of just storing it in their pocket. it looks like assigning data to an attribute, but behind the scenes there are methods, just waiting to weave spells on said data.
When I take a property out of a class and abstact it, so that it can be used by many classes, it’s called a descriptor. (kinda like abstracting functions out of program files and into modules)
To kinda formally state, a descriptor is a class whose instances are supposed to be class attributes in other classes.
- To fit the descriptor protocol, a descriptor class needs to implement…
  - a __get__(self, host_instance, host_class) method with a corresponding __set__(self, host_instance, new_value_to_set) method
- These are class specific. As in, the descriptor is shared amongst all the instances it is used in.
- To get instance specific descriptors, you set the value that you are changing to be assigned as a dictionary using the host instance as the key and the value, as the value. (More contorting!) and then return the value of the [host_instance] value.
- Definitely tons of practice needed with this.
- Not used much, in day to day work, but used heavily behind the scenes by Python itself for its object system. The methods, Python classes have, are plain old functions, with descriptors (in conjunction with weak referenced elements) applied to them.
- The more I dive into all of this, the more Python feels less magical and more like the work of thousands of hard working atomic elements. And I think, I like this better. That everything complex, is actually lots of simple pieces, working together in concert.

** Part 5, Advanced Topics **

The only thing I can write here, is that Reuven goes deep into hijacking how Python creates classes and then using them for our own customised ends. How to create my own custom __new__ method, my own custom __init__ method, my own custom type of object, create my own class with a metaclass…
Never going to use this, unless I am writing the next Django or something, and even then I doubt, these would be needed 😂
But this was so much fun to learn!

Read all about my Python Objects journey here

A Hundred Days of Code, Day 016 - Python, Advanced Objects.

feedback@janusworx.com (Mario Jason Braganza) — Fri, 24 Jul 2020 20:34:43 +0530

Started up with Python Objects today.
This seems like a long, hard one.
Here’s hoping I learn lots.
Knowing Reuven, I know I will.

Notes
#

Part 1, Advanced Methods.

This section focuses on the dunder methods in Python.

By default objects are not equal to other objects even they they are from the same class, with the same attributes and methods.
- We could implement our own equals method though.
- The point being, we need to be intentional and methodical, when we design and implement our classses
Static methods are plain old functions that I write in my class for use by both the class and the instance. Could be used to clean up input or similar such utility functions. I create them by putting a @staticmethod decorator atop my method.
Class methods are those that are meant for use by only the class. I can call them from my instances, but they act on the class. I create them by using the @classmethod atop my method. For clarity, the first variable is now written as cls instead of self.

Part 2, Inheritance.

MRO, Method Resolution Order. I can do an classname.__mro__ to see how Python goes about looking for methods upwards, specially if I’m inheriting from multiple objects. Running help on an object also lists the MRO of its methods.
Best to explicity inherit from all parent classes, when inheriting from multiple classes.
We can use the classname.__bases__ to check for the classes parents.
A mixin is a class, we can inherit from (probably in addition to and before our parent class), that just adds functionality to our class. Does nothing sematically / organizationally to our objects or classes.
- The mixin must come first.
Adding an __ before an attribute, signifies that it is not to be touched. A little security by obscurity too. Nothing’s stopping me from actually going and changing things up. It’s just a notifier to people with common sense that such stuff ought not to be tampered with.
- The main reason though is to prevent conflict between attribute names.

Learning / Feedback/ Experiences from doing exercises
#

This course feels like the O’Reilly cookbooks in video form.
The first section takes all the operators, I take for granted in Python and then shows me how to implement them with my own classes
- how do I get len to work on my object? or how do I implement the == operator in my classes? etc. etc.
Starting with the last one and this one, have given up on exercises and just taking notes for now. As soon as I finish the run, I will be then going on an exercise binge with these pending exercises as well as Reuven’s Python Workout.
- The execption being, if I run into a topic that is really confusing, then I will attempt the exercises to drill the idea immediately into my head.
Obligatory Reuven plug, since I started up a new course :)
- Reuven is an awesome teacher.
- He takes the time, to explain stuff in painstaking detail, leaving nothing as an “exercise to the reader”.
- All of these courses, so far have been worth every single penny I spent on them.

Read all about my Python Objects journey here

A Hundred Days of Code, Day 015 - Python, Advanced Functions, Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 24 Jul 2020 11:32:03 +0530

Delving deeper into Python functions and learning more about them, using Reuven Lerner’s Advanced Python Functions Course

Notes
#

The co_* series of attributes inside the __code__ attribute inside most functions gives a wealth of information about a function.
- For example, looking up the argcount attribute for some function hello, with hello.__code__.co_argcount will give us the number of arguments hello takes.
- And doing a hello.__code__.co_varnames will give us a tuple of all the local variables in a function
- hello.__code__.co_code contains the compiled bytecode for the function.
  - Importing the disassembler import dis and running it on the bytecode, dis.dis(hello) will show us what’s in there.
- hello.__code__.co_flags keeps a track of whether the function has * arguments or not via a binary switch. (It holds many parameters, one of which is the on/off switch for *args)
  - if said switch is set, the function checks for such arguments at runtime and turns them into a tuple to process.
  - they are set for *args via the hello.__code__co_argcount switch (0/1) and for keyword arguments with the hello.__code__.co_kwonlyargcount switch.
the __defaults__ attribute keeps all the functions default variable values. If I don’t supply a value to some parameter, the function will look in here, to see if a default value exists. hello.__defaults__ could hold a last name default, for example, if I want my hello function to work even if no last name was supplied, and it actually expected a full name.
- do not use mutable defaults. an empty list or dictionary for example.
- set the default to None first in such case and then create the list when the function runs at runtime.
The last thing I learnt about were nested functions.
- I can nest them two/three/as many levels deep as I wish. Practically, most folks do two or three.
- When an inner function takes the variables of its enclosure and does something with it and returns stuff…? those kinds of functions are called closures.

Learning / Feedback/ Experiences from doing exercises
#

The course so far is Reuven making simple functions and then breaking them down and explaining functionality in painstaking detail.
Reuven is an awesome teacher! I would gush about him every post, but then it would get too much 😂. So once per course is good
I kept looking at the disassembled code and wondering, what language it was. I still don’t know. My ‘educated’ guess is that it is a level of standard pseudo-assembly code for some phantom standardised processor. Once I had that mental model in mind though, all of it started making a lot more sense. This brought memories of Z80 assembly, I learnt in the mid 90s
This was fun to do! Onwards to Advanced Objects!

Read all about my Python Functions journey here

A Hundred Days of Code, Day 013, Day 14 - Python, Advanced Data Structures, Done!

feedback@janusworx.com (Mario Jason Braganza) — Wed, 22 Jul 2020 17:48:09 +0530

Notes and experiences for yesterday and today.
I ‘wasted’ a lot of time, again, struggling with exercises yesterday and ended up being too zombied to even write the summary post.
Have been much smarter about it today.
Stopped after about 30 mins and copied and tried to understand the solution.

Notes
#

List of Dictionaries

Just more convenient than a list of lists, not particularly faster
Make it more flexible.

Dictionary of dictionaries

Think beforehand of what your keys are going to be.
Looking in them, faster than lists
The tradeoff is more memory usage

Dictionary of Lists

Works when you need disparate elements to work with later. Those can be stored as dictionary values, in a list form.

Part 3

Decimals

To have something sane between integers and crazy floats.
I import the Decimal class and then create objects, like so

from decimal import Decimal
a = Decimal('0.1')
b = Decimal('0.2')

I create them from strings not floats, just like I would int strings.
It has various methods I can call on the Decimal object.
- Stuff like getcontext with has a method to set the precision of units after the decimal point.
Helpful if you need precision at a certain level.

Named Tuples

A very handy way of calling values in a tuple by sensible names, just like dictionaries
Very handy instead of heavyweight dictionaries.
Create them like so

from collections import namedtuple 
Person = namedtuple('Person', ['first', 'last', 'age']) 
me = Person('Jason', 'Braganza', 42) 

Doing a me.first will get me Jason, just like a dictionary.
I can still refer to the tuples with the numeric indices.
I can do a ._replace to replace values, if I want to. me._replace(first ='Mario'). It just returns a new object with the same name, which I can choose to catch in a new variable.
Better for readability.
Basic uses. The moment I want to twiddle with it too much, I know I should just make my own classes

defaultdict

A variation/improvement on the normal dictionary.
We want a dictionary, with default values.
When I check for the presence of a key, if it does not exist it’ll get created with a default value.
We give it a function or a class, that will run, be called everytime a key does not exist.
So I could pass it basic primitives, like a list with no entries and it will return an empty list for a value everytime, there is not one. Or saying int, in which case it will create a key with 0 for a value
Create them like so

from collections import defaultdict 
d = defaultdict(int) 

So now when I do d['a'], it well check for key a. If it does not exist, it will create it, and give it a value of 0 by running the int function with no arguments.
I can use any function or callable, as long as it has no arguments.

OrderedDict

No need to use it anymore
But handy in case I am looking at old code.
Regular dictionaries order stuff chronolgically as of Python 3.7.
Which is what ordered dictionaries used to do.

Counter

from collections import Counter
if I pass an Counter dictionary an iterable, it will create a dictionary with the occurrence of each element.
if I go c = Counter[10, 10, 20, 50, 60, 60, 80, 80, 80, 90'], then I get a dictionary like Counter({10: 2, 20: 1, 50: 1, 60: 2, 80: 3, 90: 1})
I can also do a most common method to get the most frequently used elements. c.most_common()

Enums

from enum import Enum
Create ’em like

class ColorEnum(Enum)
Red = 1
Blue = 2
Green = 3

Matches symbolic labels / names to numeric values.
If a = ColorEnum.Red and b=ColorEnum.Red then they would both be equal.

Learning / Feedback/ Experiences from doing exercises
#

Reuven keeps harping on the fact, that I need to think things through.
- Is this how you want to build things?
- What are the ramifications?
- What if you want to change up things or if things are expected to grow exponentially in the future?
- Think! Be itentional. Design accordingly.
Caught myself frequently initalising a total in a loop and then wondering why I would not get the actual total :)
Now my approach, kinda matches what Reuven does. Which means, I am beginning to write some sane code :)
Finished with this course. And on to the next one. Planning, building in margin and working at it a little bit everyday helping a lot!

Read all about my Python advanced data structures journey here.

A Hundred Days of Code, Day 012 - Python, Advanced Data Structures continued

feedback@janusworx.com (Mario Jason Braganza) — Mon, 20 Jul 2020 16:21:04 +0530

Ok! Had a nice refreshing break, yesterday being Sunday.
Back to work today!
If today’s notes, feel a little light, that’s because I was struggling with exercises.

Notes
#

Part 2

A lightweight solution to classes, if I am just combining all sorts of data structures is the built-in collections. Some of them could be
- List of Lists
- List of Tuples
- List of Dictionaries
- Dictionary of Dictionaries
- Dictionary of Lists
Mostly use them to solve tricky issues. If I find myself using lots of functions, just to deal with these structures, I am better off using classes.
- These structures also lend themselves to being converted into classes.
- Sometimes it’s just a matter of adding a few methods, et voilà, I have a class!

Lists of lists

As simple to create as l = [[1,3,2],[4,5,6],[7,8,9]]
- If I do a l[0], I’ll get the first element, the list [1,3,2
- To get at the elements inside that list, I can go l[0][2] which will give me the number, 3.
- Behind the scenes, l.__getitem__(0).__getitem__(2)
We can either work with them with indices like up above, or iterate over them, with for loops or comprehensions
Better to use lists of tuples, if I am dealing with mixed types, specially those that are not apt to change, like records of some sort. Something like a list of details about movies.

Learning / Feedback/ Experiences from doing exercises
#

Learning to think atomically. Learning to break down each exercise into pieces and then learning to organise them in a manner, that I can solve it, step by step.
- What hints do Reuven’s results show?
- What should I compare first? What will be the aftermath? and so on.
Gave up an exercise after two hours of trying.
- After peeking at the solution I realised that it was not because of something I forgot or did not practice, but once again, because of something I did not know.
- in this case that there are set operators to use between two iterator objects.instead of crazily stepping through everything like I did below, I could’ve just created a union list run through them.
Just goes to show, there is lots for me to learn. And that there is a lot of tacit knowledge out there. And this I will only be able to figure out by writing lots of code!
Also (note to self), time your self and be ok with giving up and looking at the solution. I seem to keep thinking that I am wrong or am missing something. Never the fact, that it might be something that I do not know.
- I am now strictly going to give myself 30 minutes per exercise and then move on.
Lots of mistakes as usual.
- Wrong indentation, giving weird results.

Read all about my Python advanced data structures journey here

A Hundred Days of Code, Day 011 - Python, Advanced Data Structures

feedback@janusworx.com (Mario Jason Braganza) — Sat, 18 Jul 2020 19:14:17 +0530

Started with a new Reuven Lerner Course, on Advanced Data Structures..
Aiming to comfortably finish this in a week.
Notes and experiences, follow.
The course is three parts.

Part 1 - Deep dive into the common data structures
Part 2 - Combining Data Structures. Lists of lists, Dicts of lists, Tuples of Lists and so forth. How far can I go without classes? Or how can I enhance my classes with this approach?
Part 3 - Complex data structures, that come with the Python Standard Library. The Collections module, Weak references etc.

Notes
#

Part 1

The id of a variable shows me where the object in refers to, is located in memory.
If x=5 then the id(x) will point to where it’s object, here the number 5, is located in memory.
When I assign a variable to another, what I actually do is assign the new variable to the same objects address. That is all. When I do x = y, then y will point to 5 too, independent of x. If I set x to something else later, y is not going to follow x. Instead it steadfastly points to 5.
A simple way to say this is x is y, where I am not checking for equality, but rather testing the fact, that both of them point to the same location in memory, or not.
I can use sys.getsizeof() to find the size of an object in memory. (how much memory it uses), but it’s a tricky beast. For e.g. when it shows me the size of a list, it shows me the size of the list object. Not the size of the elements it contains. To get that, I need to go check the size of its elements one by one.
A singleton object (not many in Python) is an object that every time you create a new instance of, from the parent class, it always points back to the same instance. None is an example in Python.
Better to create a list using square brackets, rather than assigning them via a string. x = ['a','b','c','d'] works better than going x = list('abcd'). This obviously matters upon what you are doing and if that is possible to do or not.
I can tuple-unpack-split a string in various ways. If I go, a, b, *c = s.split[] it will get the first split item in a, the next one in b, and the rest will be a list in c. But if I want the first and last elements for example and don’t care about the stuff in the middle, I can also go, a, *b, c = s.split(). I need to play with this. Just realised I could’ve solved a lot of exercises I did in the past, more elegantly if I knew this then.
If I access an element in a sequence via its index, I will get the element back along with the elements type, but if I slice a sequence to get just one element back, I get a single element of the sequence’s type. Very nifty!
- For example if I access s[0] in the list ['jason', 'braganza'], then I will get a string jason back.
- But if I slice and get just the first element with a s[:1] (get upto, but not including 1), I get a single element list, ['jason'] back.
If I look up a key z in a dictionary d with a d[z] and it does not exist, then I get a KeyError. If I want to check keys without noise, I use the get method on a dictionary. If the key exists, the value is returned. If not None comes back.
- I can set keys similarly with the setdefault key if I want to set keys safely. If I just do d[z] = 100 and z already existed, its value would have gotten trampled and set to 1000. But if I do the samething with a d.setdefault(z, 100) then it sets it to 100 only if the key does not exist. If it does, it just returns the old existing value. No harm, no foul.
If I have two dictionaries and I want the contents of one in the other, then I use the update method. For e.g., I have dictionary a and dictionary b, so I do a.update(b) and everything from b flows into a.
- If there is overlap in the keys, then the values get trampled and overwritten.
I normally cannot add dictionaries, lists, or other sets to my sets (no unhashable types allowed), I can freeze a set with frozenset, which makes it hashable and then add it to my set.

Learning / Feedback/ Experiences from doing exercises
#

Reuven makes Python sound like a cute animated bear. ‘Python notices and says “Oh, you’re using 256. I’ve aleady got that. Don’t create a new object for that!”’ I wish my interpreter was as helpful 😂
This course is a lot less structured than the basic courses. It approaches you from the point of view, that you know stuff, you can read and write Python, you have a modicum of intelligence, so here’s a really juicy grab bag of interesting stuff about all the basics you learnt earlier.
- It’s best to always use f-strings, but if you need to eke performance, can you figure out, what kind of strings are the best? (spoiler, benchmark it)
- While Python lists are expandable, the C structures underyling it are fixed. How does Python let you have flexible, expandable lists then?
And so on and so forth. So far, this has been fascinating.

Read all about my Python advanced data structures journey here

A Hundred Days of Code, Day 010 - Python Functions, Basics Done!

feedback@janusworx.com (Mario Jason Braganza) — Fri, 17 Jul 2020 19:36:18 +0530

Today was hard!

Notes
#

‘*args’

way to get multiple arguments without having to assign placeholders for them
it scoops up all the arguments and gives it to the function in a tuple. I could then loop over it with for.
I just put * in front of one of my placholders et voilà, def example_func(*catch_everything)
I can define placeholders to catch specific arguments, but those need to be before my ‘*args’.
Edge Case: I could have my arguments in a list/tuple already. I can just add the structure with a * in front of it and Python will unpack it for me. If I have a list, catch_me_if_you_can=[1,2,4] then I can pass the elements individually, as arguments with a def example_func(*[catch_me_if_you_can])
Another kinda frequent edge case: ‘*args’ catches everything that is unassigned. so if i have something with a default value, it will get trampled by the data from my args. Best thing to do is to set the default after the ‘*args’ like so, example_func(a, *args, b=10)

Keyword Arguments

Normally in the form of name = value
Kinda like addressing lists vs dictionaries. Where instead of an index, I can now call an argument with a name.
So I can go def name(FirstName='', LastName='') and then put in stuff in whatever order I want to like name(LastName='Brontë', FirstName='Emily'. Pretty handy!
Try not to mix and match positional and keyword arguments. Python looks for positional arguments first, then keyword arguments. So if you have them, then the positional arguments have to come first!

‘**kwargs’

these scoop up keywords arguments into a dictionary. I can do everything with this, just like any other dictionary
I just put * in front of one of my placholders et voilà encore, def example_func(**catch_everything)

Combining Arguments

Arguments in decreasing order. Stick to the order as far as possible.
- mandatory parameters (no defaults)
- optional parameters (with defaults)
- *args
- **kwargs (with and without defaults)
Use them for different kinds of input

Variable scopes

Just because I have indentation, with an if or an else or a for, does not mean that I change a variable’s scope. Variables within those indented blocks could still be global, or the scope of the thing above
The slight exception is the variable within comprehensions. Variables inside them, have their own private scope
The scope changes, mainly, when we define functions. Generally …
- If I am in a function, I’m in a local scope
- If I am out of it, I’m in a global scope
- with some exceptions
So always think, am I in a function body … or not? (excepting comprehensions)
When Python looks for variable values it looks in the LEGB sequence. (left to right).
- Local (starts here if I’m in a function)
- Enclosing
- Global (starts here if I’m not in a function, rather in the main body of the program)
- Built-in
The globals function will have all the global variables for the program. It’s a dict with variable names as keys and the variable assignments as values
The locals function will have all the local variables for a function in the program, when it runs. It’s also a dict with variable names as keys and the variable assignments as values or I could also look at the function_name.code.co_varnames to peek at the local stuff
- Parameters to a function are also local variables.
- I should define my local variables, before I use them in a function, or I get an UnboundLocalError
- If I want to use and modify a global variable in a function, I should declare it at the beginning of my function. For example, if I have a global variable x, and I want to use it in a function, then I say global x in the beginning of the function.
- I can mutate elements of global variable, if they are mutable structures. As in, I cannot change list A to another set of entries, but I can append to list A, or delete items from list A. As long as you are not assigning to a variable, rather using object methods, you should be ok.
The built-ins scope, houses many things that are needed by Python, but are not reserved keywords. Stuff like list. I can use it to create lists, but it’s not reserved. I can redefine it if I want to (or more commonly redefine it by mistake)
- This feels like one of the few places, Python allows me to shoot myself in the foot.
- Do a dir(__builtins__) and review the names every now and then, and don’t use them in your code.

Kinda Advanced Stuff

While I said, they were verbs, functions can alse be nouns. I can just pass them as objects to other functions or elsewhere.
I can pass a function as an argument as in the case of sorted(someIterableofPositiveNegativeNumbers, key=abs) where I am passing the abs function as a keyword to the sorted function, which then uses abs to get the absolute values of the numbers first and then sorts them according to those values.
I can collect arguments for the inner functions I call with *args and **kwargs and then pass to them again with *args and **kwargs.
I can also take some data as an argument along with a function and apply that function to that data. Like I did above. The main function I create acts like some glue program. This process of applying function to data, is called mapping and the functions I create to do this are map functions. Python has a built in map function.
I can create functions, plop them into a dictionary and then call them as needed in my actual function, by accessing the dictionary keys and supplying arguements. This approach is called a dispatch table

Learning / Feedback/ Experiences from doing exercises
#

Getting used to the way, Python behaves. And beginning to love its consistency for the most part.
I write slow, step by step code. while it works, Reuven’s solutions are short and make me go, oh why did I not think of that? Maybe optimised thinking will come with time?
I have to use Python tutor a lot to get what is actually happening.
I’ve learnt to just dive in blind when begining to write programs. The more I think about stuff, the more I feel, like I can’t do this. So I just start. And build it line by line, error by error. And more often than not, it solves it self. Optimised solutions present themselves after I have the rough and ready solution done. “Aah! I could’ve written it this way”
And I am done with the introduction to functions! Hurrah! This course stretched me a bit, and showed me I still have a ways to go.

Read all about my Python functions journey here

A Hundred Days of Code, Day 009 - Python Functions, Basics

feedback@janusworx.com (Mario Jason Braganza) — Thu, 16 Jul 2020 16:12:47 +0530

Started up with learning about Python function basics, today. Notes follow. Using the Lerner pool of wisdom, as usual.

Why do we need functions?

DRY (Don’t Repeat Yourself), because we can take stuff that is repeatable, assign it a nickname and just call that nickname over and over, instead of tediously writing all that stuff over and over and over
If want to modify something, I can just call it (by the nickname) and then add my little spice to it. Like I have the recipe to an omlette written down somewhere, I can then just add a little note with secret ingredients at the bottom of that recipe to create a better or a different omlette.

Functions are objects.

We can think of them as verbs

Parentheses in Python (at the end of functions) basically mean, I want to execute, this here thing, on the left

I can run help on a function to get some information about it.
help(str.upper)

We don’t tack parentheses on the function, when I am lookif for its help, because I don’t want to run the darned thing.

Creating/Defining a function

We define a function using the def keyword. It’s followed by the name you want to call it by, followed by parantheses terminated by a colon
- def hello():
- This is actually a two step thing, even though I’ve always thought of it as one.
  - first, I create a function object.
  - then, I assign it a name.
- Functions in Python (unlike other languages), have the same name space as the rest of our Python program. I cannot have a function called x and also a variable called x

Returning results

Similar to math functions, even Python functions return values after running them
The default is None, unless you actually, explicity tell the function to return something
If you want to catch the results of what you are doing with the function, remember to return it.
A function can return whatever you want. statements, values, other functions etc.
Which is good and all, but remember to do this with intent. I ought to think about what I want to return and document it well
If I am returning multiple values of varying types, it comes back as a tuple. Not as different objects. I need to unpack them and assign them to multiple values explicity

Documenting Functions

The help function needs something to read and tell the user about what our functions do. Ergo …
Use docstrings (Documentation Strings) to do it.
- What are docstrings? If the first line in a function is a string, then that string is seen by the help system as a docstring and used for documentation.
- Use triple quotes around the string. I can have multiple lines in there
- The convention is to document what a function receives (the input), what it returns (the output) and what it modifies.

 def hello():
		"""This is it! The docstring! This will help me figure out what the hello function does!
		or more seriously
		expects: No arguments
		modifies: Nothing
		returns: A friendly greeting
		"""
		return 'Hello, hello :)

**Arguments**

Functions need stuff to work with.
We supply them using arguments.
Just a fancy name for the data we pass along to the function.
E.g. If a function returns a fancy format of our name, there must be some mechanism to pass our name across to the function. Arguments are how we do it. We don’t actually argue with the programe :P

A function can take any number of arguments. We just put them between the parentheses, seperated by commas

Positional Arguments
```
def hello(first, second):
 print(f'Hello, {first} and {last}')
```
- In the code above, I can call the function with hello('Tyche','Hestia') and it will assign Tyche to first and Hestia to second, because I typed them in that order.
- These are called positional arguments
- When I define a number of arguments, I need to pass all the arguments along. I can’t make space for two and pass only one or none.
- I can supply defaults, so that if the user does not supply all the arguments, the default is used in its place
- If some arguments cannot have defaults and are a must, they must come before the ones that are optional and can have defaults.
- How does Python know, how many to expect?
  - When Python defines the function, it records the definition and makes a note of what it needs to run the function properly
    - If I look at the guts of the hello function with a hello.__code__.co_argcount it’ll tell me, it has recorded two.
    - If I supply defaults, they are recorded in a seperate place called hello.__defaults__ and it supplies the requisite information, so the argcount always stays at the required number of arguments

A little dazed today, so calling it quits early.

Learning / Feedback/ Experiences from doing exercises
#

I keep looking for elegant, one statement like solution to problems and get frustrated. Reuven then shows up with a brutally efficient solution that has four if statements. I should remember to be more workmanlike, before I turn craftsman

Read all about my Python functions journey here

A Hundred Days of Code, Day 008 - Python Basics, Lists, Tuples, Dictionaries, Sets and Done!

feedback@janusworx.com (Mario Jason Braganza) — Wed, 15 Jul 2020 19:32:58 +0530

This was an amazing run! Learnt lots.
Done with the basics course.
Woohoo!

Notes
#

With lists
- Not pythonic to mix types
- can iterate, slice and dice, search, get lengths, transmute them (for e.g. reverse items in them) just like strings
- can have lists of lists!
- lists are mutable, unlike strings. can change items/elements of a list
  - If i create a list from another list, the new list items reference the old list items
  - if i want to copy elements from a list rather than reference them, I’ll go newlist = oldlist[:] which will copy the elements from the old list into the new one, rather than create references to the old ones
- Realise that there is a difference between changing the values of a variable and between changing elements of a list.
  - When I do x = 2 and y = x and then change x to be x = 3, remember that the value of y does not become 3. y continues to point to the original location in memory which holds 2. What I did was to break x’s connection to that value and assign to another value in another location
  - On the other hand, when I do x = ['jane', 'jill', 'mary'] and then create a copy with y = x and then change x[0]='edith', what I do in this case is change the actual element. The references to that object in momory stay unchanged. Which is why y[0], which holds references to the same object, will also reflect the change to edith.
  - Finally if I go, x = ['athena', 'diana', 'aphrodite'], now we’re back to the assignment. x will point to this new list while y points to the old one.
  - This distinction between changes in assignment vs changes to content is very important, when dealing with mutable/changeable data types like lists
- Append something to a list with .append - list.append(something, something else)
  - Heuristic, when a method on a mutable data type, changes data, in returns None
    - So I should just go mylist.append('blah') and stuff will be done
    - If go mylist = mylist.append('blah') (which I am very apt to do) the method will change the list, then return None and that None will get assigned to mylist, In effect, erasing the list and causing unnecessary heartache. So, be careful, very careful. Not careless, like Bond, James Bond.
- += or .extend takes an iterable on the right. picks each element. and then assigns them singly to the list on the left.
  - Append can take only one item.
    - If I want to add xyz as separate entries to mylist that has ['a','b','c'], append will just take it as a big lump and make ['a','b','c','xyz']
  - Instead I do a +=
    - mylist += 'xyz' or mylist.extend('xyz')will give me ['a','b','c','x','y','z'], which is what I wanted in the first place
  - it will only work if there are iterables on the right. (strings, lists, dictionaries etc.)
- the insert method will let you insert something at a location in the list.
  - Give it what you want, tell it where you want, and boom!
  - mylist.insert('d', 3) will put d after abc, giving me ['a','b','c','d','x','y','z']
- I can replace things in a list by giving it a location and telling it what to put in there.
  - I could do mylist[0]='artemis' and the list will change to ['artemis','b','c','d','x','y','z']
  - I could also give it a slice along with a list of what to put in there. Doing mylist[1:2]=['josephine','lisbeth'] will now give me ['artemis','josephine','lisbeth','d','x','y','z']
  - if you add additional elements, than what you replace, Python will insert them, growing the list.
- Removing things from a list?
  - the .pop method will pop off the last item in a list.
    - If i give it a location, it will remove the item at that index location. mylist.pop(3) will remove d from mylist giving me ['artemis','josephine','lisbeth','x','y','z']
  - When I know what I want to remove, I just use the remove method instead of pop.
    - mylist.remove('josephine') will remove poor Josephine leaving us with ['artemis','lisbeth','x','y','z']
    - If I’m not sure, I could check for the presence of an item before I remove it. Should prevent a program from barfing on me if that element isn’t there
      if 'q' in mylist: mylist.remove('q')
    - also the remove method only removes the first instance of something.
- Iterating and counting over lists?
  - the for loop!
    - I can use the enumerate function if I want numbered items out
  - I can iterate over a slice.
- The range function is very list like in its behaviour.
- I can sort lists.
  - same caveat as above. sort will change the list in place and return None. Don’t go assigning mylist = mylist.sort(). It won’t work
  - A .sort(reverse=True) will sort in reverse
  - sorting between mixed types in a list doesn’t work in Python 3 anymore. The types in a list, ought to be the same.
  - Sorting list of lists works by comparing indices
  - If I don’t want to change my original list, I can use the sorted function on the list.
    - It works on most iterables, not just lists, while the list method is restricted to lists
    - It returns a new sorted list, and keeps the original list intact.
    - I can do sorted('something', reverse=True) will return a reversed list.
I can str a list and list a string
I can split a string into a list, either by single characters or by a delimiter (a ; or a , or space)
- split without an argument will cut out all white space
I can join, strings and lists and stuff, but
- join works only on a string. it’s a string method
- and that string generally is the glue, that will string what we give it, together
- ' '.join(['Hail','Caesar']) will join the list using that blank space I gave it.
- it works backwards, so that I can feed it any sequence in the end. a list, a tuple, a dictionary … all fair game
- Remember, it won’t work on numbers. It’ll fail.
Tuples, are a kind of weird hybrid of strings and lists.
- Like a string, they are immutable
  Like a list, they can contain anything at all.
- crazyTuple = (1, 2, 4, 5)
- you create them by enclosing with () brackets. but that is just for you to know you are creating a tuple. I can just do crazyTuple = 1 2 3 4 5 and that creates a tuple just as well.
- I can do most everything with them just like strings and lists, slice, search, iterate blah blah
  - Typically used to create structures. like bookdetails = ('title', 'author', 'pubdate', 'price'). you know what to expect, once you see definition. Once we figure that [0] is the title, it normall will be the same for the other books too.
  - Behind the scenes in Python, function arguments are passed as tuples.
  - Note:* If elements in my tuple are mutable (like a list), I can change their elements, like appending or deleting items in the list. The tuple however is immutable. I cannot delete/modify the list item as a whole.
  - use extend if you want to append to a list in a tuple
  - Since a tuple is immutable, it doesn’t have a sort method. I can however sort by using the sorted function which will return a sorted list of the elements of the tuple, whill leaving the original tuple untouched.
Unpacking stuff
- If my variables on the left, match up to the number of items in the structure on the right, x, y, z = (10, 20, 30) then they get assigned to each. x is assigned 10, y,20 and z,30.
Dictionaries
- Hash tables, hash maps in other languages
- While in a list, I have values of my choice, the index is always numeric. so item 0 is a cookie, item 1 is cookie-dough and so on, with a dictionary, I get to define the indexes too! I can now say endresult is a cookie, ingredient is cookie-dough and on and on
- while if you want to append to a list, you use an append method, if you want to add keys (user defined indexes), you just assign it to a dictionary with its corresponding value. So I can just add cookie_recipe[sugar]=100 to my cookie recipe dictionary above. if the key is already in there, it just gets updated with the new value. if not, the key and the value get added to the dictionary.
- Keys are unique. Values can repeat. But keys can exist only once in a dictionary
- I can use most immutable data types as keys. strings, integers, tuples that don’t contain mutable data like lists etc.
- I can use in to look for keys in a dictionary. 'sugar' in cookie_recipe
- The get method will look for a key for you. If it exists it will return the key, or if there isn’t, it returns None. I could even customise the none with a message. If i do d.get('somekey', 'No such key'), it will print “No such key” if the key isn’t found.
- The setdefault method will set a key in the dictionary along with the value, if it does not already exist in the dictionary. If it exists already, it will return the existing value.
If I want to convert strings to numbers and want to do a sanity check (I would not want to convert text after all, Hello is not a number :P) then I can use the isdigit method on the string. It’s a string method to use on strings.
Sets, can be thought of as dictionaries without any values.
- Each value in a set can occur only once.
- create them by going myset = set() and then I can willy-nilly add values with myset.add(10) or myset.add(32). If I try adding same value twice, no dice. It is stored only once. Every value is unique
- I can use an iterable to add multiple items at once with the update method. I can pass a list for example, and it will add all the unique values to the list. myset.update([44, 777, 44, 56, 89, 777])
- I cannot have mutable / changeable data as elements of set. No lists, no dicts etc. Strings, Numbers are ok
- While sets look like lists, they are unordered with no indexing.
- I can iterate over them, though.
- To look for something in a set, use the in operator
- To remove the item use the remove method
- I can do set operations. s1 - s2 will show me items that are unique to s1. (it removes the common elements between the sets) or vice versa
- the symmetric_difference method will show me unique elements from both sets. stripping off the common elements. s1.symmetric_difference(s2)
- to find if a set is a subset of another I could use the <>= operators. Is s2 a subset of s1? s2 < s1
- I can combine sets (union) s1|s2
- Or I can find the common elements with intersection s1 & s2

Learning / Feedback/ Experiences from doing exercises
#

Reuven keeps going, Alright? And I keep nodding my head here :)
Still miss lots of stuff, writing code. Missing colons, no surrounding quotes, missing commas, so many commas … not converting strings to integers and then wondering how I get such large results from simple addition
But I’m done!
These were the basics, and I could run through them, but I did not realise I had so many gaps in my basics.
As I keep saying Reuven is amazing. He points out the pitfalls and keeps reminding me of important issues and shows various methods to solve things, keeps encouraging me and I could go on and on. Lerner fan for life!

Read all about my Python basics journey here.

A Hundred Days of Code, Day 007 - Python Basics, Variables, Basic Data Types, Strings and Loops

feedback@janusworx.com (Mario Jason Braganza) — Tue, 14 Jul 2020 18:26:08 +0530

Started with the Reuven Lerner, Intro Python:Fundamentals course today.
Made surprising headway, even though today was crazily demanding with work and personal stuff.

Notes
#

The difference between == and is
- If you want to see if two things are equal, use ==
  - like, is 2+2 == 4
- If you want to know if two objects are the same thing. if they are just pointers to the same memory location, use is. The heuristic is, if you are checking for singleton values, something that there is only one thing of; then in Python, we use is. Use sparingly . Make sure you check mostly to see if things are the same object or practically to see if something is None
  - mostly to check for the presence or absence of things.
  - like x = None and then I go check if x is None …
True / False heuristic in Python
- Nearly everything in Python is true
- except for False, None, 0 or anything empty (empty lists, dictionaries, etc.)
Learnt how working with strings in reverse works
- if I want the last element in a string, I could reference it by calculating it’s length and lopping one off (since indexes start at 0), like with the string s = 'Halt! Who goes there?' I could access the last element by s[len(s)-1] or the last but one, with a s[len(s)-2].
- This is made a lot more convenient by just dropping the len(s) stuff, just leaving the - numeral part - s[-1] or s[-2]
- This makes so much sense in my head now, if what I am doing is counting straight and then subtracting one. I should remember, things sometimes are simpler than they seem :)
  For some reason, I always imagined, Python could see the length of my string, so why couldn’t there be a reverse string way of doing things like s.rev[0] that would just count backwards 😂
Strings are immutable. They can’t be changed. I can just process a copy and generate new ones, though.
just realised that the f in f-strings stands for formatted strings, since when I write raw strings, I use an r for, duh, raw strings
Slicing involves carving out a small contiguous part out of a larger string. The thing to note is that when I say s[0:4] it means upto, but not including 4
- If I say s[0:100], slices are forgiving and give me upto the end of my small string, without throwing an error.
- Empty colons in slices imply endings. s[:10] means start from 0 and go up to 9. Or s[9:] means start at 9 and go upto the end. Ergo s[:] means from the beginning to the end.
- I can have step sizes to step over. The default, hidden size is 1. I can step, oh, say every three elements by append :3 to the end of my slice like so, s[0:20:3], basically [start🔚step size]
- I can also have negative step sizes which will give me the results in reverse. The most common one being -1, because the quickly reverses a string for me (commonly done). But it works with other step sizes too. A -2 will start counting backwards every other character from the end. A reverse slice begins with the end character and then beginning. So s[10:5:-1] to carve out a slice backwards.
Sequences are strings, tuples and lists. They all can be sliced and diced and iterated upon.
Heuristic, else in a for loop is to match stuff when I don’t encounter a break. the else part matches the for to form the for-else construct, even though the break is inside the for loop
while loops are for when you don’t know the end of what you are looking for. there is not finite end. No 0 - 10 happening. You are just searching for something in an amorphous swamp. The swamp is vast, there is no way to say from this end of the swamp to that end.You only give up when you find what you are looking for, or when you decide it’s time to give up (some preset condition).
- make sure there is a counter that breaks stuff or I might loop forever

Learning / Feedback/ Experiences from doing exercises
#

Realising why Python notebooks are used. Very, very, very, handy to quickly write prose and code at the same time. It fits my mental model of programming perfectly!
I keep thinking strings and characters are English and forget to quote them! The number of NameErrors I get, is not funny.
Thing that keeps biting me when I write or statments. I should remember to say if x='blah' or x='meh'. I keep writing if x='blah' or 'meh', which is wrong.
I keep using a lot of superfluous variables. I should be more intentful. Instead of just printing an expression, I tend to figure out the expression, assign to a variable and then print it. Good for building, probably bad for optimal use. But I won’t worry about it too much now. Just something to improve on in the long term.
Reuven is a painstakingly methodical teacher. If he’s so good in his videos, I am jealous of folks attending his live classes

Read all about my Python basics journey here

A Hundred Days of Code, Day 006 - Starting and Quitting Comprehensions

feedback@janusworx.com (Mario Jason Braganza) — Mon, 13 Jul 2020 18:21:31 +0530

I know I said, I’d start with the basics, Reuven, but please forgive me this once :)
Will do the rest, bottom up :)

Have started up with this, because I’m fascinated with how folks manage to build in so much functionality into short, easy to read statements.
To my mind, comprehensions are the pithy proverbs of the programming world.
So here goes …

Notes
#

This style of writing code, comes from functional programming
Functional Programming is another style of writing code
- It assumes that data is immutable. (Or at least it treats it as such) It does not change the originals I work with. (I assume this means that I always work on a copy or something)
- we work with sequences of data and create new ones based on the old ones (changing case of a sentence, comes to mind)
- There are a bunch of techniques/patterns/heuristics that’ll let me do that
- We can treat functions as data and pass them around as arguments to other functions.
- The functools module assists with writing such code
Why code in such a manner? Some benefits include them being easier to read, easier to debug, shorter, more understandable.
Distributed Computing / Multiprocessing across processors and cores/threads makes these techniques more relevant in this day and age
My personal need is to write easy to read code, like when I see a well crafted list comprehension
If I want to square a list of numbers, my current go to is to generate a new list, using a for loop. Comprehensions are a better way of doing this
For loops are far when I want to execute something on each item of something iterable, like a list or a dictionary. when i want to have a statement happen
If just want to transmute the elements of list into something else, change each element, like square them all above, then comprehensions are my friend
Here’s a list comprehension to square a list of numbers from the list numbers.
- [one_number * one_number for one_number in numbers]
- The square brackets make it a list comprehension. If I want dictionary comprehensions, I would abut them with curly braces {}. And if I use (), I’ll get a generator expression (which I know only the bare basics about)
- For loops and comprehensions might look similar, but they really are different
Note: whatever expression you use to generate output has to return something. like the square expression above . because what I want to do is catch all my results in a container. functions (like the print function) that return None as their result, cannot work here. They will display stuff, but store only None in our comprehension container :)
I can also write the comprehesion over multiple lines (works because they are bounded by the list brackets here or bounded by other brackets elswhere)

[one_number * one_number		 
 for one_number in numbers]

here with the breakdown of the lines, the first line becomes my output generator; the expression I want to use and the second line, the data I want to process. Much more readable this way

learning / feedback/ experiences from doing exercises
#

Exercises today required a bit of head scratching and a bit of research, but were relatively simple
I should keep in mind that the computer can go crazy too. I kept wondering why my code wouldn’t run and and kept banging my head for an hour. Even Rueven’s solution was what I did. Until I restarted my Jupyter note book and everything worked the way I expected.
Should have a time limit on how much struggling I do. From the last week, it looks like I am a real sucker for pain otherwise. Half an hour tops and then go look up the solution.

Have reached the second set of exercises and realised why Reuven told me to start with the basics. I failed with the second one in this set. I just know, there is a simple solution and I cannot seem to get it. This basically means … yes … that my foundations are creaky.
Note to self, walk before you can run. By Jove, you should’ve learnt that by now! :)
So this is me, waving goodbye sorrowfully to comprehensions.
Will start with the basic Python course tomorrow.
But I’ll be back soon enough, damn it!

Read all about my comprehensions journey here

A Hundred Days of Code, Day 005 - Magic Methods and Winding Up OOP

feedback@janusworx.com (Mario Jason Braganza) — Sun, 12 Jul 2020 19:23:05 +0530

Done with Reuven Lerner’s OOP basics

Notes
#

len does the right thing across multiple types of objects.
- it counts characters in a string, elements in a list, and key-value pairs in a dictionary. how does it know how to do that?
that is because len uses a magic method (methods that have a __ for a prefix and suffix)
- len uses the __len__ method which i can use in my own classes, to implement a len method for my classes
If I choose to do so, I need to realise what those underlying methods expect to return and return the same type in my classes. __len__ expects to return integers, so when I implement it in my classes, I ought not to return a string. Once again Reuven strongly suggests using common sense :)
same thing when i try to print something. it calls the magic method __str__ to do stuff. or if i try to do repr to check for raw representations, the __repr__ method is called.
Python is filled with these methods which I can use to allow my classes to have standard Python like functionality. like a print(doggie) should give me details about the cute pup object i just created, if I have taken the time and attention to implement the __str__ or __repr__ methods
most of these methods come with the base primitive class object which every class inherits from. so i get them for free. and then i can override them and customise them to what I want to show.
people try standard methods on new objects. implementing them is much better than creating my own and asking people to use ’em.
if both are equal or really similar, ok to just use only __repr__. later when I have experience and other needs, i can implement __str__ too

learning / feedback/ experiences from doing exercises
#

Despite warning myself above, I went ahead and made the mistake of returning a whole lovely string, instead of an integer, when I tried to implement the len method on my class XD
and then I forgot to add the f prefix to an f-string and wondered why it was not interpolating for nearly 30 mins
Reuven has a wry sense of humour. In one of my exercises I get to create classes of animals for a zoo, with various attributes such as colour and legs and so forth. Then he has me put them in cages. After making me put 2 sheep in a cage with a wolf, he wonders if the legs of the sheep ought to be reduced or not XD
The number of typos I am making is staggering. Missing colons, missing quotes, missing brackets. If this is Python, I shudder to think how I’d fare if I picked up a static language to learn XD
Wasted another half an hour because I spelt colours with capitals like Black and then later looked for black and was tearing my hair out, because I knew there were black animals and why in tarnation, would Python not show me them XD
Saw Reuven do nested comprehensions and now I want to do that too! it took him one well thought out line to do what I did in 2 multiline functions

Final Words
#

This was amazing!
I learnt so much about classes and the way they work.
Reuven has a very joyful pedagogy.
I love him go hahahaha like Santa Claus.
I love the fact that he makes mistakes.
I love that for every problem, he poses, he has various approaches.
His fluency shines through every lesson.
I got lucky with the Pycharm Humble Bundle.
But I loved this so much, that I am going to sign up for all the Lerner courses, I possibly can.
Beginning with the basics.
If OOP is any indicator, the journey is going to be lots of fun.

Read all about my OOP journey here

A Hundred Days of Code, Day 004 - Class Attributes and Inheritance

feedback@janusworx.com (Mario Jason Braganza) — Sat, 11 Jul 2020 17:47:49 +0530

Learnt about Class Attributes and Inheritance, today.

Notes
#

The way we write functions/methods and define classes might look similar,
class CrazyTalk(object): and def how_now_brown_cow():
The way they behave/execute, though is wildly different.
Classes run / spring to life as soon as the program launches.
Functions don’t, unless they are called.
Realised that objects are containers.
What you can do with the object depends on what is in it.
Does it hold a dictionary with various methods to modify it?
Does it just hold a bunch of text?
Reminds me of media formats as containers.
A mp4 file is not just an mp4 file.
The video resolution could vary from one file to another.
The type of audio encoding could be different.
It could carry multiple streams of audio or video or other metadata.
What you can do with the file or where you can play it, depends on what is inside it.
Same with classes and objects.
Any thing that we define inside a class, is an attribute. (methods, variables etc.) Reuven made a point of stressing this, so writing this down.
If I just define a variable and try to use it, I’ll get an UnboundLocalError. I need to use className.variable when I call it.
So I can just write a variable like so

class SomeClass():
	crazy_var = 'Muahahahaha'
	def __init__(self):
		print(SomeClass.crazy_var)

and then call it with SomeClass.crazy_var or when I do it after I define __init__ then I can just directly define it as SomeClass.crazy_var (which sounds more logical to me), like so

class SomeClass():
	def __init__(self):
		print(SomeClass.crazy_var)
SomeClass.crazy_var= 'Muahahahaha'

A class attribute is associated with the class itself, while object attributes are associated with the objects that are created from the class.
So with car.wheels, the wheels are associated with the car class, but when I use car to create a Ferrari object, and it has Ferrari.white_wall_rims the rims are an instance attribute that belong to the Ferrari object / instance and not the car class it was made of.
If I ask for an object’s attribute and it isn’t there, then Python goes looking upwards to check if the class has it. In the previous point, if I go Ferrari.wheels it’ll work, because Python will check the Ferrari object and if there are no wheels in there, it’ll go check cars.
Name your attributes carefully.
Don’t have the same names between class attributes and object attributes.
Use your head!
Don’t do that!
When we create a class, that is identical to another with one or two teeny exceptions, when they are so similar that I base the new one on the old one — those new classe are said to be inheriting from the old one. They have an is-a relationship.
For e.g. a doggie is-a floofy animal.
A teddy bear is-a floofy animal too.
Both of them inherit their floofiness from the floofy animal class.
I can write that as class Doggie(FloofyAnimal):
Note: Methods are attributes on a class. They are not attributes of the instance object.
Note: If you have an __init__ method in your inherited class, the instance will not look for __init__ variables/details in the parent class.
(it’s like this in Python, Java/C++ can get stuff from the parent / grandparent. this is so, because with Python, everything is a live object whereas with the other languages, the __init__ stuff are declarative rules with orders of precedence (a la CSS) and the class comes alive only after all the rules are parsed.)
If you do want to inherit something from the parents __init__, then you explictly get it by using super(). as in get it from the supervisor above, i guess? I’d add a line like this to my doggie class

class Doggie(FloofyAnimal):
	def __init__(self, name):
		super().__init__(name)

And then it will pull the name from the Floofy Animal class if it’s in there.

Use inheritance only when it makes sense. No need to go hog wild.

learning / feedback/ experiences from doing exercises
#

Slowly getting the hang of list comprehensions. I should practice them more.
Because they are very easy to read later.
Just that, I get very confused while writing them.
Doing the exercises is slowly getting easier
Reuven is very hands on, has tons of jokes, and makes tons of typos.
I’ve gone from eyes glazed, looking at the his code and struggling to understand to yelling at the screen when he mistypes something :)
Shows that I am learning :)
Python Tutor is very handy to see the the thousands of mistakes I make.
Even that interface does not quite make me understand, but it gets me 80% of the way there.
(like when a return statement of mine was nested in a loop instead of being out at the end of the for statement.)

Read all about my OOP journey here

A Hundred Days of Code, Day 003 - Methods

feedback@janusworx.com (Mario Jason Braganza) — Fri, 10 Jul 2020 19:44:34 +0530

Learnt about methods today.
Notes follow …

My understanding about methods? They are functions in classes that help me manipulate the data the objects contain when they are created.

I have been using something them subconsciously all along.
The __init__ method, that is called/run automatically every time an object is created.

Aha
A nice way to unpack the .notation i use

Let’s say I have a class SquareNumbers that has a function (method) — x2 — that will, you know, square a number.
And then I create an object f with a number and call the square method on it.

f = SquareNumbers(10)
f.x2()

What I am actually doing, when I call f.x2() can also be written as SquareNumbers.x2(f).
I am sending a message x2 to the f object, and it will respond with however/whatever it is programmed to.

When I define object variables in a class, I should refer to them with a self.variable when I define methods.
I figure because each object can have it’s own set of values for those variables and I want Python to find them properly.

Also learnt this is not the case in most other languages.
With some languages, you set and get values of variables of the object, using even more explicit methods, call getters (accessors) and setters (mutators).
These are just fancy names for explicit methods to assign and then read data from the variables of a class.
In our example above, I would probably have a set_x function defined to set the value of x like f.set_x(20) (along with a corresponding get_x to read it)

This could also be because other programs have different categories of data (private, public) in classes, while Python does not.
Just differences in language design philosophies, I guess.

I can create an class, that can use objects created by other other classes.
For example, I can create a book class and then have several book objects.
And then create a new bookshelf class, whose objects can take all my books and put them in a list/library of sorts
This kind of relationship is called a has-a relationship in programming parlance.
(like my bookshelf has-a book on it)
It’s also called composition. I am composing a new class from other classes.
I can do what I want with the list in the bookshelf.
I could take their prices (if i added them) and then sum them up.
I could take the titles and list them alphabetically, or by author.

Aha

So what is becoming clearer to me is that classes can take user needs, and express them naturally, while leaving the creation of these calculations and listings and sortings with the programming language primitives behind the scenes.
For my book shelf i could just go shelf.sort.title.alphabetical()
Or if I have a new need tomorrow, hmm, like finding the total prices of all my books, I could just add a sum method to my bookshelf and I could go shelf.sum().

It basically makes my code, more human. More easy to understand. More natural.

Another thing that just occured is that I could swap out the primitives beneath the classes. If I find a faster, better way to sum up prices, I could just use that. While the way I would sum the books would still remain shelf.sum()

Doing the exercises, I realise that I need to learn a lot more Python vocabulary.
I somehow managed to gather a number of variables into a list.
But when I attempted to do it again, it threw an error.
And that’s when I learnt I could extend a list.
Lots more practice needed!

The self thing bit me hard!
I spent at least a 45 minutes trying to find out why my method could not find a variable, despite me defining it correctly. I should’ve obviously referred to it with self.variable!

Time to call it a day.

Read all about my OOP journey here

A Hundred Days of Code, Day 002 - Basic Exercises

feedback@janusworx.com (Mario Jason Braganza) — Thu, 09 Jul 2020 19:15:05 +0530

Did a few exercises today.
They were simple.
Create a few classes, change them, modify them, use a list as an attribute and so on.

In a couple of ways, this was just what I needed.
One, I had an extremely busy day at work, and so I did not have the brain power to do anything complex, so I needed the bar really low any way.
And two, I’ve realised, that I have always tried to just read a book and then leap mountains. I don’t know why. I must be a sucker for pain. And then when stuff does not work, I sulk and get frustrated.
Easing into hard topics like this, makes it more enjoyable for me and I learn better.
This is a meta skill, I should remember to use.
Come to think of it, everything I have learnt recently, actually learnt, has been this way.
I learnt Dvorak and touch typing, slowly, key by single key.
I learnt to diet and lose weight, by tens of grammes in the beginning.

So, note to self.
Start small.
Do the work.
Show up daily.

Read all about my OOP journey here

A Hundred Days of Code, Day 001 - Beginning With Classes

feedback@janusworx.com (Mario Jason Braganza) — Wed, 08 Jul 2020 18:08:05 +0530

Notes I’ve taken from the videos I watched, today. This is my attempt at Feynman-ing (below), what I learnt so far.

Classes and Object Oriented Programming started to come together for me, when I saw Kushal using them.

To use my father’s carpentry analogy, I could in theory just hammer nails into wood to join them.
But to make a really strong joint, I could use other methods.
I could screw pieces of wood together, which is markedly better than just nailing them.
I could chisel wood and create a dovetail or mortise joint.

So it all comes down to understanding what I want to do and figuring out the best technique to get it done.

Like I mentioned in the toot, I could in theory just kludge together all my primitives and create something.
But, if I want to create something beautiful and something that I (and others) can understand, I need to use a different method.
Object Oriented Programming, is a popular one.

Objects and Types (In Python)
#

We have objects and types/classes.
We can think of them like we do about cells in our body.
Python for the most part is natively made of objects.
Nearly every primitive I have come across in Python is an object.
Strings are objects and work a certain way / Skin cells work a certain way.
Dictionaries work a certain weay / Optical cells in the eye, work in an very specific manner.
Integers are objects and have their own ways of doing things, as do white blood corpuscles.

Objects are a special type of something.

A class makes objects.
An int class makes integers. A string class makes strings. And so on and so forth.

With Python even classes (the constructors) are objects.
So, there must be some kind of God / Creator thing that makes these primitives / originator classes.
And there is.
It’s the type class.
It’s the base class, the bottom turtle, if you will.
The type class creates all these primitive classes, which we then use to create other objects for our use.
The type of the int (integer) class is type as is the type of the str (string) class.
They are all objects of type type.

Which basically, again to use a physical analogy means that type is the iron forge, which i then use to create factories, which i then use to fashion usable things.
The forge lets me create lug nuts and chassis’ and then I take all these, to create a car factory, which lets me make cars of different types and sizes, with varying amounts of power.
The forge lets me create some mixer, which i can then choose to setup different sorts of mixer factories. Some can make ice cream, some can make porridge.
type (the forge), creates the int class (the factory), which lets me create all sorts of integer numbers to play around with.
type (the forge), creates the dictionary class (the factory), which lets me store and sling data about in various ways.

Note: This might not be true of other programming languages (for e.g. int might be a base primitive.)

Attributes
#

Every class can have attributes (data, or methods to manipulate data).
Those attribute themselves could be classes, having their own attributes.

Now each of those takes memory.
Python doesn’t gobble up all our memory however, because some (most?) objects share memory.

Run dir on an object to get it’s attributes.
For example, I could do this on the str class to see what it has.

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

I spy with my little eye, that any string object lets itself be split or joined or lets its case be altered and much, much more!

I can go into any object I want (with few exceptions) and change its attributes!
For example, I type os.sep to get the path separator. (on a linux machine it’s / and on windows it’d be \ and if python ever ran on classic Mac os I guess it’d be :
I can just change os.sep to be ! or hahaha or whatever i want!
Or I could just add whatever attribute I want to any object!
In short, I can set and get attributes on any object I want!
Sounds pretty free-ing! Will have to see what this means in practice!

Aha
The inbuilt functions that I have learnt are not the norm.
Most code is written in classes and functions are available as methods of those classes.
Ruby natively works this way.
Python pragmatically, has created some functions as primitives.
(One possible reason could be, for example, rather than have a len method on every in built class, they musta thought it easier to create a primitive len function that worked on different classes and data types)
In real life (and across programming languages) I should mostly be looking at object.method(), for e.g. some_list.pop()
If I want to look at how to manipulate something, the general heuristic is to look at methods first. Does an object support manipulating itself through itself? After all, it knows itself best! :)

If I want to know what methods an object supports, I can of course call dir on it, but a better cleaner way is to call help on it. (help(list)). It shows, more clearly, the methods an object supports.

Why Classes
#

Do I need to create classes?
Of course not, I have been creating programs without them all these months.
A couple of reasons I’d create a class,

To stop kludginess. I don’t to expose a list of dictionaries, that contain more dictionaries that have lists as their values. better to abstract them away from the user (future me) and present simpler interfaces.
I love to write well crafted prose. Classes represent complete sentences in human language. Nouns and verbs amounting to a sentence that makes sense and is well crafted.

How do i create a class
#

Aha
Just realised that when I create a class, I am creating a new type of primitive for myself.
My own data type!
I can create my own numbering system if i want to!
Muahahahahahahaha
(comes back to reality)

class somethingsomething(object):
	pass

That is all I need. Just to say class, create a class with this here name! And *Abracadabra-Alakazoom*, Python goes ahead and creates a new class for us!

As I wrote above, this is a factory, to create new somethingsomething objects.
I can do that by just assigning it a name. Like Iron man summoning his suit out of thin air.

somethingblue = somethingsomething()

And boom! The object `somethingblue` materialises!

This is just a blank template, of course.
I cannot do much with this. (Right now, I don’t even know, what I can imbue this with, or use it for :P)
So I guess, the rest of the course will probably deal with how to make classes work and function the way I want them to.

I can add attributes to my classes just by declaring them.

somethingblue.color='sky'

somethingblue.liquid='ocean'

somethingblue.code=0x0000FF

And then i could `dir(somethingblue)` and it will give me them attributes, along with a list of everything it has inherited from the parent class (here the `type` class)

A neater way of looking at only what I defined, is to do vars(somethingblue)

Aha
Heuristic - While i can add attributes willy-nilly to any object I want to, it’s bad form.
The idea being that the factory (the class) should ideally provide a set of default attributes and values, so that not too much monkeying is required.
This process/template of assigning sane attributes is called a constructor.

The way we create a class is two fold (very Smalltalk-esque)

I create a class.
I add its attributes.

So when Python goes to create an object of the class, it does it like quite similarly

it creates as new object when i say object = class_whatever(), using the __new__ method
it then goes looking to see if there is an __init__ method in the class, and if it exists, then to use that to setup the default attributes
it uses the self (by convention) argument, to assign those attributes to the object. (I am applying shampoo to mine own self)
and then assigns it to the variable that’s supposed to catch the instance.
(I always somehow assumed it was the other way around. A variable in memory was assigned and then created like a building. This is more nature like. Stuff grows and then is assigned a name)
I can absolutely go do what I want, assign attributes however, but if I want to stay sane, I’d rather follow convention

And that’s about all I studied today.
Follow along the my Python OOP train here.

P.S. The Feynman Method.

A Hundred Days of Code, Day 000 - Begin Again

feedback@janusworx.com (Mario Jason Braganza) — Wed, 08 Jul 2020 11:01:33 +0530

How do I begin this post?

By simply beginning :) Again!

This probably is the fourth (or is it fifth) time, I’ll be attempting to learn how to program.
And probably the same number of attempts at #100DaysOfCode.
I did 47 days last time and 37 days before that.

I will try my utmost to go the distance this time.
Because even if I didn’t complete a full run, I still learnt tonnes from all my previous efforts.
I do have a beginner’s grasp of Python.
And I hope get even better, much better, this time.

What am I going to do?
Well, I want to do Miguel Grinberg’s Flask Course, but as I stumbled through it the last time, and when I read other folks’ code, I realised that I need to get much better at understanding Object Oriented Programming.

So that’ll be the focus now.
And Reuven Lerner’s OOP Course is what is going to help me.

So here I set sail again …
Now, bring me that horizon!

Python on Janusworx

Hack Hugo Post Metadata With Python

anki-push-u, Creating a Tiny Pushover Addon for Anki

derb; Script to Create podcast RSS feeds

Setting up house #

Creating a feed #

Adding episodes and writing out the file #

Serving #

TIL: The Difference Between a CLI Tool and a Freeze Tool

What I Learned Today (8th of February, 2023)

Python #

Linux Mint #

Update #

Hugo #

Huginn / RSS #

Urdu #

Physical Fitness #

What I Learned Today (7th of February, 2023)

Python #

Busywork #

Urdu #

Physical Fitness #

What I Learned Today (6th of February, 2023)

Python #

Hugo #

Urdu #

Physical Fitness #

What I Learned Today (4th of February, 2023)

Python #

Urdu #

Webdev #

Physical Fitness #

Thoughts #

What I Learned Today (3rd of February, 2023)

Python #

Devops #

Urdu #

Physical Activity #

What I Learned Today (2nd of February, 2023)

Python #

Devops #

Urdu / French #

Physical Activity #

Books / Reading #

What I Learned Today (1st of February, 2023)

Python #

Devops #

English #

Urdu #

Physical Activity #

Django #

What I Learned Today (31st of January, 2023)

Python Morsels #

Urdu #

Physical Activity #

Devops #

French #

FOSS.training / DGPLUG Summer Training 2022 Begins

So, what is it? #

Updated Poemfeed

Installing PyCLD3 on an Apple M1 Mac

I’ve Joined Scrollstack

To my Teachers, With Gratitude

Learning Backend WebDev, Log #1

A Day of Updates

Nikola Upgrade #

Pleroma Bot #

Git the Branch

Poem Feed

Starting Work on Git-the-Branch

The Itch #

What I did today #

A Good First Day

Getting Back on the Horse

A Hundred Days of Code, Day 026 - Refactoring

A Hundred Days of Code, Day 025 - Comprehension Exercises

Reflections and Experience #

A Hundred Days of Code, Day 023, Day 24 - Tiny Utility to do comparative DNS Lookups

Problem - Compare domain lookups, against DoH Servers #

Notes #

Setting up house
#

Creating a feed
#

Adding episodes and writing out the file
#

Serving
#

Python
#

Linux Mint
#

Update
#

Hugo
#

Huginn / RSS
#

Urdu
#

Physical Fitness
#

Python
#

Busywork
#

Urdu
#

Physical Fitness
#

Python
#

Hugo
#

Urdu
#

Physical Fitness
#

Python
#

Urdu
#

Webdev
#

Physical Fitness
#

Thoughts
#

Python
#

Devops
#

Urdu
#

Physical Activity
#

Python
#

Devops
#

Urdu / French
#

Physical Activity
#

Books / Reading
#

Python
#

Devops
#

English
#

Urdu
#

Physical Activity
#

Django
#

Python Morsels
#

Urdu
#

Physical Activity
#

Devops
#

French
#

So, what is it?
#

Nikola Upgrade
#

Pleroma Bot
#

The Itch
#

What I did today
#

Reflections and Experience
#

Problem - Compare domain lookups, against DoH Servers
#

Notes
#

Experience
#

Code.
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Notes
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

Learning / Feedback/ Experiences from doing exercises
#

Notes
#

learning / feedback/ experiences from doing exercises
#

Notes
#

learning / feedback/ experiences from doing exercises
#

Final Words
#