Forem: Gagan Deep Singh

Make Command: A Magical Way for Automating Stuff

Gagan Deep Singh — Wed, 30 Jun 2021 10:18:11 +0000

In this mini-tutorial, you will learn how to write a Makefile for automating stuff from project builds to whatnot, which is executed by the make command in Linux

Why? 🤔

Cause it's used in many many projects for building stuff cause when you have to compile thousands of files for a project and ensure that each file is older than the compiled file, then Makefile saves the day!

Why? (Explained) 🤔✨

Imagine you have a project which has tons of files dependent on one or another and they need to be compiled at once, compiling them manually is gonna take way too much time!

Also, if you are compiling a file that is already compiled from the latest version of the source file, then you would be compiling it again (what a waste of time and resources!).

You can write a script file for automating the whole process but for ensuring the dependencies are compiled properly, it's gonna get real complicated real soon.

*Le `make` command: "Hold my Beer" 🍺

make uses a Makefile for automating the whole process of building stuff from start to finish.

If dependencies are files, it will ensure they are updated and if they are already updated according to the source code, it won't update them (Saving time and resources!).

Also, you can individually build each dependency with make if you want to.

Structure of Makefile

target: dependency
    action

Details 🗒

target: target file or command that will be invoked when a user executes the make command with following Command-Line Argument make target
dependency (optional): they can be as many as you want (space separated) and they are a dependency for building that specific target
action: that's where you type the commands that need to be executed for building that target

Note:

If a user simply executes make without any option, the target named all will be executed.
Before typing the command for building the target in action, ensure to add a tab instead of spaces or it will keep saying ":makefile:4: *** missing separator. Stop." or something like that.
Dependencies can be files as well in the local directory.

Example 1:

Save the following code in a file and name it Makefile

all: one two
        echo "Executed all"

one:
        echo "Building one"

two:
        echo "Building two (part 1)"
        echo "Building two (part 2)"

I kept it simple so we can understand how make works...

Now execute the `make` command like this:

make

Output:

echo "Building one"
Building one
echo "Building two (Part 1)"
Building two (Part 1)
echo "Building two (Part 2)"
Building two (Part 2)
echo "Executed all"
Executed all

Breaking down how it executes

It Builds dependencies first if don't exist
It Builds the target when dependencies exist

How the above `Makefile` executes

(using `make all` or `make` command)

It checks if dependency one and two exist, if they don't exist (or is outdated), They become a target and their dependencies are checked, if they don't have any, then the commands (actions) are executed for building them.

Then finally, the all target is built using those dependencies.

Example 2 (with same `Makefile`)

If for some reason, you wanna build the individual dependencies, simply specify the target while executing the make command.

Say you wanna build one

make one

Output:

echo "Building one"
Building one

If it had any dependency, it would have built before this.

Same goes for building two

make two

Output:

echo "Building two (Part 1)"
Building two (Part 1)
echo "Building two (Part 2)"
Building two (Part 2)

End of Article

Now you know a little bit about how you can use the make command in Linux for automating stuff from builds to what not.

Optional

If you find this article useful, then leave a like and support me by following me on Twitter.

Thanks for reading 😃

Strings and their Methods in Python 3.9 🐍

Gagan Deep Singh — Mon, 02 Nov 2020 20:52:29 +0000

A bit on what strings are and their METHODS (which make life easier) !! 🔥🔥🔥

NOTE:

Almost all of the content in this article is taken from the official Python Docs, and divided into digestible chunks so that people like me can understand it (little by little).
This article is pretty straight forward. I tried to make it as crisp as possible.
It's more code and less talk cause:

Let's get started! 🐍🔥

What are Strings?

In Short:

Strings are a sequence of characters, used for storing Textual Data.

Examples ✨:


'Hello, World!' # single quotes

"This is an example(!) of a String" # double quotes

"Single 'quote' embedded in double quotes and vice versa is allowed"

'''Three single quotes and double are allowed! You can also embed 'single quotes' and "double quotes" just the way I did in this example.'''

Also,

They are Immutable i.e. They can't be modified, just like JavaScript 🔥.

Some Very Common and Useful String (str) Methods with examples:

⭐ capitalize, center (with docs)

⭐ count, encode (with docs)

⭐ endswith, expandtabs (with docs)

⭐ find, format (with docs)

⭐ index, isalnum, isalpha, isdigit, islower, isupper, isprintable, isspace, istitle (with (simplified) docs)

⭐ join, ljust, lower, upper, rjust, lstrip, rstrip, strip, partition, removeprefix and removesuffix (Python 3.9), replace, split, startswith, swapcase, title, upper

# Common String (str) Methods in Python 3.9
# Note: Output is without quotes in prefix and suffix

s = "hello, world!"

# str.join(iterable): 
# Return a string which is the concatenation of the strings in iterable.
print(" ".join(["hello", "world", "!"])) # 'hello world !'

# str.ljust(width[, fillchar]): (Remember "center" method?)  Return the string left justified in a string of length width.
# Padding is done using the specified fillchar (default is an ASCII space).
print(s.ljust(20, "-")) # 'hello, world!-------'

# str.rjust(width[, fillchar]): same as ljust except it returns right justified string
print(s.rjust(20, "-")) # '-------hello, world!'

print(s.upper()) # HELLO, WORLD! (Returns All Characters Upper-cased)
print(s.lower()) # hello, world! (Returns All Characters Lower-cased)
print(s.title()) # Hello, World! (Returns Titledcase String)
print(s.lstrip()) # hello, world! (Returns Copy of String with Leading Characters (default=whitespaces) removed)
print(s.rstrip('!')) # hello, world (Returns Copy of String with trailing Characters removed)

print('   hello, world! '.strip())
# hello, world (Returns Copy of String with trailing and leading Characters removed) (default=whitespaces)

print(s.partition(',')) # ('hello', ',', ' world!')
# Split the string at the first occurrence of sep, and return a 3-tuple containing the part before the separator,
# the separator itself, and the part after the separator.
# If the separator is not found, return a 3-tuple containing the string itself, followed by two empty strings.

print(s.split('l')) # ['he', '', 'o, wor', 'd!'] # Return a list of the words in the string,
# using sep as the delimiter string.

print(s.replace('l', 'L')) # 'heLLo, worLd!'
# str.replace(old, new[, count]): Return a copy of the string with all occurrences of substring old replaced by new.
# If the optional argument count is given, only the first count occurrences are replaced.

# ===============
#   Python 3.9 ⭐
# ===============

print(s.removeprefix("hello, ")) # "world!"
# If the string starts with the prefix string, return string[len(prefix):].
# Otherwise, return a copy of the original string:

print(s.removesuffix(", world!")) # "hello"
# If the string ends with the suffix string and that suffix is not empty,
# return string[:-len(suffix)]. Otherwise, return a copy of the original string

A little bit More ✨:

f-strings

Gagan Deep Singh

@gagangulyani

f-strings in Python 🐍:

“formatted string literals,” f-strings are string literals that have an f at the beginning and curly braces containing expressions that will be replaced with their values. [Source: realpython]

P.s.
Learn f-strings and write cleaner and more elegant code.

17:03 PM - 12 Aug 2020

That's it! 🐍🔥

To Dig More into strings and stuff, click here (where most of the content of this article is taken from).

Thanks for reading. 🙏🏻

Feel free to leave a comment if you want to add up something or suggest what I should share next :)

Automating my workflow with Python #1: File Organizer

Gagan Deep Singh — Tue, 25 Aug 2020 17:45:55 +0000

This is my first article on Automating my workflow with Python.

In this (beginner-friendly) article, you will learn how you can make your own Python 🐍 script for organizing files for your own workflow just the way I did.

What problem did I fix? 🤔

I tweet a lot of Python 🐍 snippets, make videos, and work on projects which require me to download a lot of Images, Videos, and whatnot!

I don't get time to organize my downloads 📂 and if I want to look for a file...

Source: makeameme.org

So, I wrote a Python script to automatically organize my files in one go. ✨✨

Before the script 😰

This is how my Downloads folder usually looks like...

Yeah, it's an unorganized mess 💀

After the (magical ✨) script 😄🥰

This is how my Downloads folder looks like now...

It looks cleaner than my room now 🤩

As you can see that all files are now organized 📂✨!!
Cool, Right!? 😎😎

After writing the script, it's a lot easier for me to look for anything, cause every file is organized and belongs to their own 📂📂, which saves me a lot of time now.

Source: cheezburger.com

The IDEA 🔥

A Script which Moves files to their respective 📂✨

For implementing that, here's what I did (abstract view):

Created a dictionary 📔 which contains the file types (extensions) and paired them with their respective 📂 names
Took input (path) from the User via the command-line argument 💻
Looked for files in that path and made a mechanism (function) for getting their respective 📂 names.
Moved 🖼, 📽, 🎵,🗒️ etc to their 📂📂📂

Source: http://www.brendanconnolly.net/keep-it-simple-theres-more-to-it/

So Let's go from this 😰...

ls command output ( before running the script )

To this 😃✨✨

ls command output (after running the script)

Steps for Writing our (Magical ✨) Script

Step #1: Creating a `dictionary` 📔 of Extensions (suffix) and Directories 📂

This part is the most time consuming (and the easiest) 😁, we just need to

Create a dictionary 📔 (Hashmap) where keys are extensions of the files and their corresponding values are the name of Directories we want to move them in.

Note: You can relate Dictionaries in Python 🐍 to Objects in JavaScript.

So, Every multimedia file has an extension:

Image files have extensions .jpeg, .png, .jpg, .gif...
Video files have extensions .mp4, .mov, .mkv, .webm...
Document files have extensions .doc, .docx, .csv, .pdf...

And so on...

So, we can Google the extensions of Images, Videos, Documents, Program Files, and whatever kind of files we need to organize and store them in a dictionary in {"extension": "directory"} pair in a variable named dirs like this...

dirs = {
    # Images
    "jpeg": "Images",
    "png": "Images",
    "jpg": "Images",
    "tiff": "Images",
    "gif": "Images",

    # Videos
    "mp4": "Videos",
    "mkv": "Videos",
    "mov": "Videos",
    "webm": "Videos",
    "flv": "Videos",

    # Music
    "mp3": "Music",
    "ogg": "Music",
    "wav": "Music",
    "flac": "Music",

    # Program Files
    "py": "Program Files",
    "js": "Program Files",
    "cpp": "Program Files",
    "html": "Program Files",
    "css": "Program Files",
    "c": "Program Files",
    "sh": "Program Files",

    # Documents
    "pdf": "Documents",
    "doc": "Documents",
    "docx": "Documents",
    "txt": "Documents",
    "ppt": "Documents",
    "ods": "Documents",
    "csv": "Documents"
}

Step #2: Taking input (path) from the user 🧑🏻‍💻👩🏻‍💻 via a command-line argument 💻

What are command-line arguments?

Here's a simplified version for those who don't know what a command-line argument is:

when you run cd command for changing directory and give it a path like this...

cd Documents/TOP_SECRET_STUFF

OR

ls Downloads

that path is called a command-line argument.

Basically, command-line arguments are values that are passed onto the programs or scripts being executed.

Now, getting back to our script 📃👇🏻

Python has a module named sys which has a function argv which returns a list of the command-line arguments given while executing the script.

Here's how it works...

When you run a python script like this...

python helloWorld.py

argv returns a list that contains all the command line arguments given.

In the above example, the first (and only) command-line argument is "helloWorld.py" which is the name of the script file.

argv returns ['helloWorld.py'].

If we give command-line arguments like this...

python add.py 2 3

argv will return ['add.py', '2', '3'].

Let's use it for taking a path from the user in our script file.

from sys import argv

# argv = ['our_script_file.py', 'path/to/dir']

# Select second element (at index 1) as path
path = argv[1] # 'path/to/dir'

There's a tiny bug in it.

If the user runs the script without providing the path, then our script will throw Index error (cause we are trying to access 2nd element but there won't be any 2nd element to access)

Though, we can easily fix that bug by

adding a condition before accessing the `path` from `argv`

That simple condition is to check if the command-line arguments are exactly 2 (name of the script file and the path).

If this isn't the case then display the Error message along with Usage like this...

from pathlib import Path

if len(argv) != 2:
    print("=" * 35)
    print("[ERROR] Invalid number of arguments were given")
    print(f"[Usage] python {Path(__file__).name} <dir_path>")
    print("=" * 35)
    exit(1) # terminate the execution of the script with code 1

# Path to Organize
PATH = argv[1]

And... It's fixed! 😁😁😁

Note:

__file__ contains the absolute path of the script file (being executed)
Path(__file__) returns a Path object (the next section digs more into it), and with this object, we can simply print the name of the script file by using the name data member with this Path(__file__).name

Now we know how we can take input from the command-line!! 🔥🔥🔥

Step #3: Scan the path for files and move them into their folders

Python has an AWESOME 😎 module called pathlib which provides Classes for working with paths.

It's so cool that it can handle paths from different Operating Systems! 🤯

For organizing files, we need to...

🔍 Look for files in the path 🛣
Check each file's extension 🧐 (file type)
Select a destination 🗺️ based on that extension
Move ✂️ files to their destination directory

🔍 Looking for files in the path 🛣

For doing that, we gonna convert the path (provided via command-line argument) into a Path Object with the help of Path class.

For doing that, we import Path class like this...

from pathlib import Path

and then use the path stored in the 1st index of argv (2nd element) and call the Path class using that

from pathlib import Path

PATH = Path(argv[1]) # argv[1] = 'path/to/organize'

For looking up the files in that directory, we gonna iterate it with the help of the iterdir method.

from pathlib import Path

PATH = Path(argv[1]) # 'path/to/organize'

for filename in PATH.iterdir():
    # Do Magic (Organize)

This is gonna help us iterate files and folders in any path! 😃

Cause we want our script to organize only files, we need to check if the filename is a file or a directory. We can easily do that with the is_file method.

from pathlib import Path

PATH = Path(argv[1]) # argv[1] = 'path/to/organize'

for filename in PATH.iterdir():
    if filename.is_file(): # If filename is a file
        # Do Magic (Organize)

Checking each file's extension 🧐 (file type)

Cause we are working with Path objects, it makes it pretty simple for us to get the extension of a file.

Let's say filename is a Path object. To get the extension name, It's stored in the suffix member of the Path object.


# filename = Path object with path value "AWESOME.jpeg"
extension = filename.suffix # .jpeg

cause we need that extension without '.' as a prefix, we gonna remove that with string slicing.


# filename = Path object with path value "AWESOME.jpeg"
extension = filename.suffix[1:] # 'jpeg'

Now, we know how to get extension names! 😄🎉

Selecting a destination 🗺️ based on that extension

The heading says it all.

For selecting a destination, we will use the dictionary we created earlier (long key: value pair thingy) and use it for getting the right destination name for every single file.


# filename = Path object with path value "AWESOME.jpeg"
extension = filename.suffix[1:] # 'jpeg'
directory_name = dirs.get(extension) # 'Images'

Cool 😎! But what if the extension is not in our dictionary 😐 It's gonna return None and we don't want None. Do we?

So, let's add a default value "Miscellaneous" as a directory name for files that are not in our dictionary.


# filename = Path object with path value "New_IMG.ppm"
extension = filename.suffix[1:] # 'ppm'
directory_name = dirs.get(extension, 'Miscellaneous') # 'Miscellaneous'

We are almost done

cause we gonna use this code, again and again, we can wrap it in a function.

Gonna name it get_dir cause it's gonna return directory name for every file it receives as input. Makes sense. Right!?

Also, adding a little docstring never hurts...


def get_dir(filename):
    """
        This function takes filename and returns name of the
        parent directory of the respective filename
        Returns Miscellaneous if Parent is not found
    """
    ext = filename.suffix[1:]
    return dirs.get(ext, "Miscellaneous")

Move ✂️ files to their destination directory (finally! 😃)

We gonna use themove function from shutil (shell utilities..?) module (Yes, another dope module in Python) for moving files from one place to another.

Moving files is super easy!. Here's an example.


from shutil import move

source_path = '/home/gagan/Downloads/Awesome.jpeg'
destination_path = '/home/gagan/Downloads/Images'

move(source_path, destination_path) # self explanatory

It's similar to executing this command in Bash

mv ~/Downloads/Awesome.jpeg ~/Downloads/Images

Source: memegenerator.net

For getting path from a Path object, we use str function which will return path in string instead of a Path object.

We gotta use it cause move function takes in

move(
  str(source_path),
  str(destination_path)
)

Create a destination directory for files to be moved in

We gonna use the get_dir function we defined earlier for creating a destination directory for each file by doing the following:

destination = PATH / get_dir(filename)

if not destination.exists():
    destination.mkdir()

We made a new Path object with the path we gave via the command-line and joined that with our selected directory name using PATH / get_dir(filename) and stored it in destination variable.

Also, we need to make it if it doesn't exist, which is done by exists and mkdir method.

Note:

"~" contains the path to the home directory (Mine is /home/gagan/)
We need an absolute path for moving files (Absolute Path refers to the full path to a file/directory)
- For getting an absolute path, we use the absolute method of Path object.
- filename.absolute() returns Path object with absolute source path of the file
pathlib (kinda) supports moving files too! But we used shutil cause it mimics the behavior of mv command and It doesn't have any issues doing its job.

Now, we know everything we need for implementing the (Magical ✨) Script! 😎🔥

🔥🔥🔥🔥

LET'S PUT EVERYTHING TOGETHER

WE HAVE LEARNED/DID SO FAR

🔥🔥🔥🔥

from pathlib import Path
from sys import argv
from shutil import move


def get_dir(filename):
    """
        This function takes filename and returns name of the
        parent directory of the respective filename
        Returns Miscellaneous if Parent is not found
    """
    ext = filename.suffix[1:]
    return dirs.get(ext, "Miscellaneous")


dirs = {
    # Images
    "jpeg": "Images",
    "png": "Images",
    "jpg": "Images",
    "tiff": "Images",
    "gif": "Images",

    # Videos
    "mp4": "Videos",
    "mkv": "Videos",
    "mov": "Videos",
    "webm": "Videos",
    "flv": "Videos",

    # Music
    "mp3": "Music",
    "ogg": "Music",
    "wav": "Music",
    "flac": "Music",

    # Program Files
    "py": "Program Files",
    "js": "Program Files",
    "cpp": "Program Files",
    "html": "Program Files",
    "css": "Program Files",
    "c": "Program Files",
    "sh": "Program Files",

    # Documents
    "pdf": "Documents",
    "doc": "Documents",
    "docx": "Documents",
    "txt": "Documents",
    "ppt": "Documents",
    "ods": "Documents",
    "csv": "Documents"
}

if len(argv) != 2:
    print("=" * 35)
    print("[ERROR] Invalid number of arguments were given")
    print(f"[Usage] python {Path(__file__).name} <dir_path>")
    print("=" * 35)
    exit(1)

# Directory Path
PATH = Path(argv[1])

for filename in PATH.iterdir():

    path_to_file = filename.absolute()

    if path_to_file.is_file():
        destination = PATH / get_dir(filename)

        if not destination.exists():
            destination.mkdir()

        move(str(path_to_file), str(destination))

Finally, Running the (magical) script 🔥

For organizing my downloads folder, I can now simply run the following command...

python organize.py ~/Downloads

Making this long command shorter with `alias`

I created an alias that executes the above command so I don't have to write python ~/projects/File-Organizer/organize.py for executing the script from any directory.

Here's how I now organize files in a path

organize ~/Downloads

SO CLEAN! 😁

This is how you can create an alias 👇🏻👇🏻👇🏻

Paste the following command in `.bashrc` file

alias organize="python /path/to/script_file.py $1"

Replace /path/to/script_file.py with the path where you saved your script file. Make sure that it's an absolute path of your script file.

Note:

$1 is the first argument that will be passed to our script file.

For activating it in your terminal, execute the following command

source ~/.bashrc

And... we are done! 😎🎉🎉🎉🎉

This was so simple! Right!?

Link to the script

cheezburger.com

I hope you guys found this article (which I realized is some sort of memeful tutorial 🤨) useful.

If I missed something or you would like to add more to it, feel free to mention it in the comments.

If you guys wanna support me, Please give me some genuine feedback on how I can improve myself and my articles.

Thanks for reading, Stay Vibrant! ✨

Creating files with Python and mimicking the "touch command"

Gagan Deep Singh — Sun, 16 Aug 2020 15:34:00 +0000

We will learn the following while working on our Python Script:

Creating files with Python
- Creating a single file
- Creating multiple files
- Providing filenames from the command line
- Testing our script
Touch command
- Getting the access time and modified time of a file
- Getting the current time
- Updating Access and Modified time in a file
- Implementing the Touch Command
Result

Creating files with Python

Creating a single file

Here's a one-liner for creating a file with Python.



open('hello_world.txt','w')

This single statement creates hello_world.txt, but we don't want fixed file names, do we?

The question is, how to conveniently provide input to the script to create a file with Python.

We can use a variable for storing the name of the file, like this...



filename = "hello_world.txt"
open(filename, 'w')

But this will be a mess if we want to create multiple files with Python, as each time we want to create a file, we would need to update filename variable manually which ain't so cool.

Creating multiple files

The solution to the above problem is, making a list of filenames.



filenames = ['hello_world.txt', 'random_file.txt', 'lol.txt']
for filename in filenames:
    open(filename, 'w')

This is MUCH BETTER 🤩! But wait, It's only good for one-time use 😕. What if we want to make more files later in a single go?

Then we would have to update the filenames list again and again. 😑

Providing filenames from the command line

For this fix, we can provide values (filenames) from the command line! 😃 We only need to make two changes in our existing code.

Add from sys import argv and use the value of argv with for filenames.



from sys import argv

filenames = argv[1:] # Ignore the first element (script file)

for filename in filenames:
    open(filename, 'w')

This seems to work just fine but there's a nasty bug in it.

If the file already exists, it will wipe the whole file's contents. Thanks to the file access mode 'w' (write mode) which we used.

The fix is very simple. We just need to replace 'w' with 'a' (append mode) which will ignore the files which already exist and create new ones if they don't.



from sys import argv

filenames = argv[1:] # Ignore the first element (script file)

for filename in filenames:
    open(filename, 'a') # Using append mode now

Testing our script

I saved the script as touch.py here's the execution...

Creating multiple files with our Python script

Existing files remain unchanged, YAY!

Touch command

Our script is GOOOOOODDD!!! 🔥🔥🔥

But there's still one thing we can add to make it behave more like touch command, that is, updating a file's access and modified time.

For the sake of keeping things simple, we will just update the modified time of the file.

Getting the access time and modified time of a file

The os module in Python has a stat function that performs a stat system call (runs a stat command behind the scenes) and returns the result in an accessible way.



from os import stat
st_info = stat(filename)

access_time = st_info.st_atime 
modified_time = st_info.st_mtime

We can use the result st_info which contains the status of the file including the access and modified time for modifying the file.

Getting the current time

time function in the time module returns the current time which we can directly use in our script for modifying the files with our script.



from time import time

current_time = time() # current time in seconds (since Epoch)

Updating Access and Modified time in a file

The os module also has a function for updating this access and modified time called utime.

Here's how this can be done,



from os import utime

# if the second argument isn't passed, it will set the access

  
  
  and modified time to current time




utime(filename)

# for setting our custom access and modified time

utime(filename, (access_time, current_time))

Implementing the Touch Command

Now, we can finally put together everything we have done so far in one final script.



from sys import argv

from time import time

from os import utime, stat

for name in argv[1:]:

  open(name, 'a')

  st_info = stat(name) # Storing file status

  # setting access time with file's access time (no change)

  # setting modified time with current time of the system)

  utime(name, (st_info.st_atime, time()))

Result

Finally, It's time we use the script for creating files and stuff.

Multiple files created Succesfully! 🔥

Our script successfully updates the modified time of existing file!! 🔥

That's it! Our script makes multiple files and mimics the touch command as it sets the modified time! 🎉🎉🎉

You can tweak it and add more features to make it a complete touch command clone.

Link to script file

Forem: Gagan Deep Singh

Make Command: A Magical Way for Automating Stuff

Why? 🤔

Why? (Explained) 🤔✨

*Le make command: "Hold my Beer" 🍺

Structure of Makefile

Details 🗒

Note:

Example 1:

Now execute the make command like this:

Output:

Breaking down how it executes

How the above Makefile executes

(using make all or make command)

Example 2 (with same Makefile)

Say you wanna build one

Output:

Same goes for building two

Output:

End of Article

Optional

Strings and their Methods in Python 3.9 🐍

Let's get started! 🐍🔥

What are Strings?

In Short:

Examples ✨:

Also,

Some Very Common and Useful String (str) Methods with examples:

⭐ capitalize, center (with docs)

⭐ count, encode (with docs)

⭐ endswith, expandtabs (with docs)

⭐ find, format (with docs)

⭐ index, isalnum, isalpha, isdigit, islower, isupper, isprintable, isspace, istitle (with (simplified) docs)

⭐ join, ljust, lower, upper, rjust, lstrip, rstrip, strip, partition, removeprefix and removesuffix (Python 3.9), replace, split, startswith, swapcase, title, upper

A little bit More ✨:

f-strings

That's it! 🐍🔥

Automating my workflow with Python #1: File Organizer

What problem did I fix? 🤔

Before the script 😰

This is how my Downloads folder usually looks like...

After the (magical ✨) script 😄🥰

This is how my Downloads folder looks like now...

The IDEA 🔥

So Let's go from this 😰...

To this 😃✨✨

Steps for Writing our (Magical ✨) Script

Step #1: Creating a dictionary 📔 of Extensions (suffix) and Directories 📂

Step #2: Taking input (path) from the user 🧑🏻‍💻👩🏻‍💻 via a command-line argument 💻

What are command-line arguments?

OR

Now, getting back to our script 📃👇🏻

If we give command-line arguments like this...

Let's use it for taking a path from the user in our script file.

There's a tiny bug in it.

adding a condition before accessing the path from argv

If this isn't the case then display the Error message along with Usage like this...

Now we know how we can take input from the command-line!! 🔥🔥🔥

Step #3: Scan the path for files and move them into their folders

For organizing files, we need to...

🔍 Looking for files in the path 🛣

Checking each file's extension 🧐 (file type)

Selecting a destination 🗺️ based on that extension

We are almost done

Also, adding a little docstring never hurts...

Move ✂️ files to their destination directory (finally! 😃)

Create a destination directory for files to be moved in

🔥🔥🔥🔥

LET'S PUT EVERYTHING TOGETHER

WE HAVE LEARNED/DID SO FAR

🔥🔥🔥🔥

Finally, Running the (magical) script 🔥

Making this long command shorter with alias

Here's how I now organize files in a path

SO CLEAN! 😁

Paste the following command in .bashrc file

For activating it in your terminal, execute the following command

And... we are done! 😎🎉🎉🎉🎉

This was so simple! Right!?

If you guys wanna support me, Please give me some genuine feedback on how I can improve myself and my articles.

*Le `make` command: "Hold my Beer" 🍺

Now execute the `make` command like this:

How the above `Makefile` executes

(using `make all` or `make` command)

Example 2 (with same `Makefile`)

Step #1: Creating a `dictionary` 📔 of Extensions (suffix) and Directories 📂

adding a condition before accessing the `path` from `argv`

Making this long command shorter with `alias`

Paste the following command in `.bashrc` file