Cara Membuat Bot dan Mengotomatiskan Pekerjaan Sehari-hari Anda

Sebagian besar pekerjaan memiliki tugas berulang yang dapat Anda otomatisasi, yang membebaskan sebagian waktu Anda yang berharga. Ini menjadikan otomatisasi sebagai keterampilan utama untuk diperoleh.

Sekelompok kecil insinyur otomasi terampil dan pakar domain mungkin dapat mengotomatiskan banyak tugas paling membosankan dari seluruh tim.

Dalam artikel ini, kita akan menjelajahi dasar-dasar otomatisasi alur kerja menggunakan Python - bahasa pemrograman yang hebat dan mudah dipelajari. Kami akan menggunakan Python untuk menulis skrip otomatisasi kecil yang mudah dan bermanfaat yang akan membersihkan folder tertentu dan memasukkan setiap file ke folder yang sesuai.

Tujuan kami bukan untuk menulis kode yang sempurna atau membuat arsitektur yang ideal di awal.

Kami juga tidak akan membangun sesuatu yang "ilegal". Sebaliknya, kita akan melihat cara membuat skrip yang secara otomatis membersihkan folder tertentu dan semua filenya.

Daftar Isi

  1. Area Otomasi dan Tempat Memulai
    • Otomatisasi Sederhana
    • Otomasi API Publik
    • Rekayasa Balik API
  2. Pertimbangan Etis Otomasi
  3. Membuat Skrip Pembersihan Direktori
  4. Panduan Lengkap untuk Pembuatan Bot dan Mengotomatiskan Pekerjaan Sehari-hari Anda

Area Otomasi dan Tempat Memulai

Mari kita mulai dengan mendefinisikan jenis otomatisasi yang ada.

Seni otomatisasi berlaku untuk sebagian besar sektor. Sebagai permulaan, ini membantu dengan tugas-tugas seperti mengekstrak alamat email dari banyak dokumen sehingga Anda dapat melakukan ledakan email. Atau pendekatan yang lebih kompleks seperti mengoptimalkan alur kerja dan proses di dalam perusahaan besar.

Tentu saja, beralih dari skrip pribadi kecil ke infrastruktur otomatisasi besar yang menggantikan orang yang sebenarnya melibatkan proses pembelajaran dan peningkatan. Jadi mari kita lihat di mana Anda dapat memulai perjalanan Anda.

Otomatisasi Sederhana

Otomatisasi sederhana memungkinkan titik masuk yang cepat dan langsung. Ini dapat mencakup proses independen kecil seperti pembersihan proyek dan penataan ulang file di dalam direktori, atau bagian dari alur kerja seperti mengubah ukuran file yang sudah disimpan secara otomatis.

Otomatisasi API Publik

Otomatisasi API publik adalah bentuk otomatisasi yang paling umum karena saat ini kita dapat mengakses sebagian besar fungsionalitas menggunakan permintaan HTTP ke API. Misalnya, jika Anda ingin mengotomatiskan penyiraman taman pintar buatan Anda sendiri di rumah.

Untuk melakukan itu, Anda ingin memeriksa cuaca hari ini untuk melihat apakah Anda perlu air atau jika ada hujan masuk.

Rekayasa Balik API

Otomatisasi berbasis rekayasa balik API lebih umum terjadi pada bot sebenarnya dan bagian "Penipu Bot" pada bagan di bagian "Pertimbangan Etis" di bawah.

Dengan merekayasa balik API, kami memahami aliran aplikasi pengguna. Salah satu contohnya adalah login ke game browser online.

Dengan memahami proses login dan otentikasi, kita dapat menduplikasi perilaku itu dengan skrip kita sendiri. Kemudian kita dapat membuat antarmuka kita sendiri untuk bekerja dengan aplikasi meskipun mereka tidak menyediakannya sendiri.

Apapun pendekatan yang Anda tuju, selalu pertimbangkan apakah itu legal atau tidak.

Anda tidak ingin membuat diri Anda bermasalah, bukan? ?

Pertimbangan Etis

Beberapa pria di GitHub pernah menghubungi saya dan memberi tahu saya ini:

"Suka dan keterlibatan adalah mata uang digital dan Anda merendahkannya."

Ini melekat pada saya dan membuat saya mempertanyakan alat yang telah saya buat untuk tujuan itu.

Fakta bahwa interaksi dan keterlibatan ini dapat diotomatiskan dan "dipalsukan" semakin mengarah ke sistem media sosial yang terdistorsi dan rusak.

Orang yang menghasilkan konten berharga dan bagus tidak akan terlihat oleh pengguna lain dan perusahaan periklanan jika mereka tidak menggunakan bot dan sistem keterlibatan lainnya.

Seorang teman saya datang dengan asosiasi berikut dengan "Sembilan Lingkaran Neraka" Dante di mana dengan setiap langkah lebih dekat untuk menjadi pemberi pengaruh sosial Anda semakin tidak menyadari betapa rusaknya seluruh sistem ini sebenarnya.

Saya ingin membagikan ini dengan Anda di sini karena menurut saya ini adalah representasi yang sangat akurat dari apa yang saya saksikan saat secara aktif bekerja dengan Influencer dengan InstaPy.

Level 1: Limbo - Jika Anda tidak melakukan bot sama sekali

Level 2: Rayuan - Saat Anda menyukai dan mengikuti orang sebanyak mungkin secara manual agar mereka mengikuti Anda kembali / menyukai pos Anda

Level 3: Konspirasi - ketika Anda bergabung dengan grup Telegram untuk menyukai dan mengomentari 10 foto sehingga 10 orang berikutnya akan menyukai dan mengomentari foto Anda

Level 4: Perselingkuhan - Saat Anda menggunakan Asisten Virtual berbiaya rendah untuk menyukai dan mengikuti atas nama Anda

Level 5: Nafsu - Saat Anda menggunakan bot untuk memberi suka, dan tidak menerima balasan apa pun sebagai imbalan (tetapi Anda tidak membayarnya - misalnya, ekstensi Chrome)

Level 6: Pergaulan - Saat Anda menggunakan bot untuk Memberi 50+ suka untuk Mendapatkan 50+ suka, tetapi Anda tidak membayarnya - misalnya, ekstensi Chrome

Level 7: Keserakahan atau Keserakahan Ekstrim - Saat Anda menggunakan bot untuk Menyukai / Mengikuti / Mengomentari antara 200–700 foto, mengabaikan peluang untuk dilarang

Level 8: Prostitusi - Ketika Anda membayar layanan pihak ketiga yang tidak dikenal untuk terlibat dalam suka / mengikuti timbal balik otomatis untuk Anda, tetapi mereka menggunakan akun Anda untuk menyukai / mengikuti kembali

Level 9: Penipuan / Bidah - Ketika Anda membeli pengikut dan suka dan mencoba menjual diri Anda ke merek sebagai influencer

Tingkat botting di media sosial begitu lazim sehingga jika Anda tidak melakukan bot, Anda akan terjebak di Level 1, Limbo , tanpa pertumbuhan pengikut dan keterlibatan yang rendah dibandingkan dengan rekan Anda.

Dalam teori ekonomi, ini dikenal sebagai dilema narapidana dan permainan zero-sum . Jika saya tidak bot dan Anda bot, Anda menang. Jika Anda tidak bot dan saya bot, saya menang. Jika tidak ada yang melakukan bot, semua orang menang. Tetapi karena tidak ada insentif bagi semua orang untuk tidak melakukan bot, semua orang melakukan bot, jadi tidak ada yang menang.

Waspadai hal ini dan jangan pernah melupakan implikasi dari seluruh alat ini di media sosial.

Kami ingin menghindari berurusan dengan implikasi etika dan masih mengerjakan proyek otomatisasi di sini. Inilah sebabnya kami akan membuat skrip pembersihan direktori sederhana yang membantu Anda mengatur folder yang berantakan.

Membuat Skrip Pembersihan Direktori

Kami sekarang ingin melihat skrip yang cukup sederhana. Ini secara otomatis membersihkan direktori yang diberikan dengan memindahkan file-file itu ke folder yang sesuai berdasarkan ekstensi file.

Jadi yang ingin kami lakukan hanyalah ini:

Menyiapkan Argument Parser

Since we are working with operating system functionality like moving files, we need to import the os library. In addition to that, we want to give the user some control over what folder is cleaned up. We will use the argparse library for this.

import os import argparse

After importing the two libraries, let's first set up the argument parser. Make sure to give a description and a help text to each added argument to give valuable help to the user when they type --help.

Our argument will be named --path. The double dashes in front of the name tell the library that this is an optional argument. By default we want to use the current directory, so set the default value to be ".".

parser = argparse.ArgumentParser( description="Clean up directory and put files into according folders." ) parser.add_argument( "--path", type=str, default=".", help="Directory path of the to be cleaned directory", ) # parse the arguments given by the user and extract the path args = parser.parse_args() path = args.path print(f"Cleaning up directory {path}")

This already finishes the argument parsing section – it's quite simple and readable, right?

Let's execute our script and check for errors.

python directory_clean.py --path ./test => Cleaning up directory ./test

Once executed, we can see the directory name being printed to the console, perfect.

Let's now use the os library to get the files of the given path.

Getting a list of files from the folder

By using the os.listdir(path) method and providing it a valid path, we get a list of all the files and folders inside of that directory.

After listing all elements in the folder, we want to differentiate between files and folders since we don't want to clean up the folders, only the files.

In this case, we use a Python list comprehension to iterate through all the elements and put them into the new lists if they meet the given requirement of being a file or folder.

# get all files from given directory dir_content = os.listdir(path) # create a relative path from the path to the file and the document name path_dir_content = [os.path.join(path, doc) for doc in dir_content] # filter our directory content into a documents and folders list docs = [doc for doc in path_dir_content if os.path.isfile(doc)] folders = [folder for folder in path_dir_content if os.path.isdir(folder)] # counter to keep track of amount of moved files # and list of already created folders to avoid multiple creations moved = 0 created_folders = [] print(f"Cleaning up {len(docs)} of {len(dir_content)} elements.")

As always, let's make sure that our users get feedback. So add a print statement that gives the user an indication about how many files will be moved.

python directory_clean.py --path ./test => Cleaning up directory ./test => Cleaning up 60 of 60 elements.

After re-executing the python script, we can now see that the /test folder I created contains 60 files that will be moved.

Creating a folder for every file extension

The next and more important step now is to create the folder for each of the file extensions. We want to do this by going through all of our filtered files and if they have an extension for which there is no folder already, create one.

The os library helps us with more nice functionality like the splitting of the filetype and path of a given document, extracting the path itself and name of the document.  

# go through all files and move them into according folders for doc in docs: # separte name from file extension full_doc_path, filetype = os.path.splitext(doc) doc_path = os.path.dirname(full_doc_path) doc_name = os.path.basename(full_doc_path) print(filetype) print(full_doc_path) print(doc_path) print(doc_name) break

The break statement at the end of the code above makes sure that our terminal does not get spammed if our directory contains dozens of files.

Once we've set this up, let's execute our script to see an output similar to this:

python directory_clean.py --path ./test => ... => .pdf => ./test/test17 => ./test => test17

We can now see that the implementation above splits off the filetype and then extracts the parts from the full path.

Since we have the filetype now, we can check if a folder with the name of this type already exists.

Before we do that, we want to make sure to skip a few files. If we use the current directory "." as the path, we need to avoid moving the python script itself. A simple if condition takes care of that.

In addition to that, we don't want to move Hidden Files, so let's also include all files that start with a dot. The .DS_Store file on macOS is an example of a hidden file.

 # skip this file when it is in the directory if doc_name == "directory_clean" or doc_name.startswith('.'): continue # get the subfolder name and create folder if not exist subfolder_path = os.path.join(path, filetype[1:].lower()) if subfolder_path not in folders: # create the folder

Once we've taken care of the python script and hidden files, we can now move on to creating the folders on the system.

In addition to our check, if the folder already was there when we read the content of the directory, in the beginning, we need a way to track the folders we've already created. That was the reason we declared the created_folders = [] list. It will serve as the memory to track the names of folders.

To create a new folder, the os library provides a method called os.mkdir(folder_path) that takes a path and creates a folder with the given name there.

This method may throw an exception, telling us that the folder already exists. So let's also make sure to catch that error.

if subfolder_path not in folders and subfolder_path not in created_folders: try: os.mkdir(subfolder_path) created_folders.append(subfolder_path) print(f"Folder {subfolder_path} created.") except FileExistsError as err: print(f"Folder already exists at {subfolder_path}... {err}")

After setting up the folder creation, let's re-execute our script.

python directory_clean.py --path ./test => ... => Folder ./test/pdf created.

On the first run of execution, we can see a list of logs telling us that the folders with the given types of file extensions have been created.

Moving each file into the right subfolder

The last step now is to actually move the files into their new parent folders.

An important thing to understand when working with os operations is that sometimes operations can not be undone. This is, for example, the case with deletion. So it makes sense to first only log out the behavior our script would achieve if we execute it.

This is why the os.rename(...) method has been commented here.

# get the new folder path and move the file new_doc_path = os.path.join(subfolder_path, doc_name) + filetype # os.rename(doc, new_doc_path) moved += 1 print(f"Moved file {doc} to {new_doc_path}")

After executing our script and seeing the correct logging, we can now remove the comment hash before our os.rename() method and give it a final go.

# get the new folder path and move the file new_doc_path = os.path.join(subfolder_path, doc_name) + filetype os.rename(doc, new_doc_path) moved += 1 print(f"Moved file {doc} to {new_doc_path}") print(f"Renamed {moved} of {len(docs)} files.")
python directory_clean.py --path ./test => ... => Moved file ./test/test17.pdf to ./test/pdf/test17.pdf => ... => Renamed 60 of 60 files.

This final execution will now move all the files into their appropriate folders and our directory will be nicely cleaned up without the need for manual actions.

In the next step, we could now use the script we created above and, for example, schedule it to execute every Monday to clean up our Downloads folder for more structure.

That is exactly what we are creating as a follow-up inside of our Bot Creation and Workflow Automation Udemy course.

A Complete Guide to Bot Creation and Automating Your Everyday Work

Felix and I built an online video course to teach you how to create your own bots based on what we've learned building InstaPy and his Travian-Bot. In fact, he was even forced to take down since it was too effective.

Join right in and start learning.

If you have any questions or feedback, feel free to reach out to us on Twitter or directly in the discussion section of the course ?