YSL-H-isaac23 1.1.4

A package for automated liking of Active YouTube Streams in the background using selenium and requests.

Youtube-stream-liker

YouTube Stream Liker (YSL) is a package developed for automated liking of Active YouTube streams by the channels provided by the user.

Note(Project Status)

The project is now done with the main goal it aimed to reach. It is now currently on the phase of creating a GUI, as I have been planning to turn this as a desktop application, although I may not have enough time to do it in the coming weeks because of school and other side projects that I want to do. As of now, the program is already complete based on what I had originally planned, though I might pick this up again in the future if I want to learn about GUIs.

Supported Python Versions

-Python 3.7 is fully supported and tested. This library may work for earlier versions of Python3 and later versions, but I do not currently run tests on those versions.

Third Party Libraries and Dependencies

The following libraries will be installed when you install the YSL library:

• Selenium
• Requests
• mysql-connector-python

For development, you will also need the following installed:

• Firefox
• Geckodriver (Make sure you put "geckodriver.exe" on the directory: 'C:/Program Files (x86)/geckodriver.exe')

How is it used?

Before making the code:

-Put the channel IDs and the channel name(or the owner's name, it's up to you) on a text file(a sample text file with the channel IDs is available above). The format of is "[Channel ID] - [Name]".(You have to do it that way, deal with it lmao)

Example:

UCdn5BQ06XqgXoAxIhbqw5Rg - Fubuki
UCQ0UDLQCjY0rmuxCDE38FGg - Matsuri
UCFTLzh12_nrtzqBPsTCqenA - Aki
UCD8HOxPs4Xvsm8H0ZxXGiBw - Mel
UC1CfXB_kRs3C-zaeTG3oGyg - Haato

0. Installation

Install this library in a virtualenv using pip. virtualenv is a tool to create isolated Python environments. The basic problem it addresses is one of dependencies and versions, and indirectly permissions.

With virtualenv, it's possible to install this library without needing system install permissions, and without clashing with the installed system dependencies.

pip install virtualenv
virtualenv <your-env>
<your-env>\Scripts\activate
<your-env>\Scripts\pip.exe install YSL-H-isaac23

1.

Create an instance of the class StreamLiker, and pass in the text file for the channel ids of the channels you want checked, the email, and then the password of your youtube account. Example:

from ysl.YSL import StreamLiker

email = '[e-mail]'
passwd = 'qwerty'
c_id = 'channels id.txt'
sl = StreamLiker(c_id, email, passwd)

2.

To start liking active streams, we first have to check if the channels that we supplied are currently streaming. To check, we can call the is_streaming() method. Example:

sl.is_streaming()

This will store the channel ids of the currently streaming channels on a dictionary.

3.

In order to like the stream, we first need to get the video links of the streams. This is when we call get_stream_links() method. (Make sure you download and put "geckodriver.exe" on the directory: 'C:/Program Files (x86)/geckodriver.exe', refer to the "Third Party Libraries and Dependencies" above.) Example:

sl.get_stream_links()

This will also store the links in a dictionary and in a text file called "video links.txt" with the purpose of keeping track of the videos that the program has already liked.

4.

Now that we have the video links, we will now like them using a selenium webdriver. Simply call the method like_videos() to get started.

Example:

sl.like_videos()

And with that, the streams of the youtubers that you want to like can now be done automatically. The user can then tinker with the code, like putting the above block of code into a for loop so that the script will regularly check the provided channels whether they are streaming or not.

Full Code:

from ysl.YSL import StreamLiker

email = '[e-mail]'
passwd = 'qwerty'
c_id = 'channels id.txt'
sl = StreamLiker(c_id, email, passwd)

sl.is_streaming()
sl.get_stream_links()
sl.like_videos()

5. (OPTIONAL)

For math nerds(I'm not one of them but I certainly will try to become one), there are additional methods that will let you use some data from the process of liking the video for the programmer to analyze. The data that are collected by the methods above are the number of active streams and number of streams that you liked for a single execution of the program.

The additional methods that are within the program is get_start_time(), get_end_time(), append_data_on_file(), and append_data_on_db(). get_start_time and get_end_time will, as their name says, get the starting time and the ending time of the liking process. The recommended placement of get_start_time is before the get_channels method, and the placement for the get_end_time is after the like_videos method.

Example:

from ysl.YSL import StreamLiker

email = '[e-mail]'
passwd = 'qwerty'
c_id = 'channels id.txt'
sl = StreamLiker(c_id, email, passwd)

sl.get_start_time()
sl.is_streaming()
sl.get_stream_links()
sl.like_videos()
sl.get_end_time()

append_data_on_file takes all the data collected by the program and then stores it in a csv file. (Note: A folder named "Stream data" must be created first in order for this method to work.) Example:

sl.append_data_on_file()

append_data_on_db takes all the data collected by the program and then stores it in your local database through mysql. The method needs the following arguments: user, host, password, database, table_name

Example:

user = 'root'
host = 'localhost'
passwd = 'root'
database = 'YSL'
table_name = 'stream_data'
sl.append_data_on_db(user=user, host=host, passwd=passwd, database=database, table_name=table_name)

start_liking_with_data(self, user, host, passwd, db, table_name)

This method combines all of the mentioned methods above into a single function in order to shorten the needed lines of code to perform all of them.

def start_liking_with_data(self, user, host, passwd, db, table_name):
    self.get_start_time()
    self.is_streaming()
    self.get_stream_links()
    self.like_videos()
    self.get_end_time()
    self.append_data_on_file()
    self.append_data_on_db(user, host, passwd, db, table_name)

The user then needs to pass the needed arguments if the user wants to append the data onto their own database. Example:

from ysl.YSL import StreamLiker

email = '[e-mail]'
yt_passwd = 'fubukibestfriend'
user = 'root'
host = 'localhost'
db_passwd = 'baqua'
db = 'YSL'
table_name = 'stream_data'

sl = StreamLiker('channel ids.txt', email, yt_passwd)
sl.start_liking_with_data(user, host, db_passwd, db, table_name)

Contribution

Any ideas related to a youtube video will be entertained and implemented in the code if decided, just put the ideas on an issue. For the code, I will be doing it myself but others can suggest ideas on how to do it. Others can also suggest ideas on how a certain part of the code can be done a lot more efficient, put those also on the issues tab.

License

MIT

Change Log

1.0.0(02/22/21)

-First Release

1.0.1(02/22/21)

-Changed the description of the package.

1.1.0(02/22/21)

-StreamLiker method append_data_on_db() along with start_liking_with_data() now accepts the table_name of a database.

1.1.3(02/23/21)

-YSL class now accessible.

1.1.4(02/23/21) -Update package description.