[Feature/Version Update] Profile Class and Database Support 🐤🤳💻

[TDKorn]

Basically, a feature branch that went too far and spiraled into a pretty much complete 100% remake of everything ✨😘

This PR has almost all of the actual code for v2.0.0.

I made this part of the stacked PR (#5) instead of merging it directly into master because the changes were so drastic that it really couldn't be merged before rewriting the README, creating accompanying documentation, and testing it more.

Overall, I am certain that these 3 weeks will haunt me. That being said, it was still nothing compared to the pain of my-magento

Feature Overview

The major change was splitting up the InstaTweet class, as it was far more focused on the settings than it was on InstaTweeting (definition), which doesn't make sense given the name of the whole thing

I've also been wanting to bring database support to the public version, as I'd written the code for it a while ago and have been using it to schedule InstaTweet and persist data remotely.

Both of these things seemed like a perfect excuse to refactor some methods into a Profile class that can easily be configured, saved, loaded, and templated in both local and remote contexts

The Profile Class

Although the Profile class is new, it's really just a polished version of the old InstaTweet.

It has the same minimum required settings

Old ⛔😲

insta-tweet/InstaTweet/core/instatweet.py

Lines 16 to 26 in 4f08d07

	self.profile_name = kwargs.get('profile', 'default')
	if not self.is_default:
	self.load_profile(self.profile_name)
	else:
	self.session_id = kwargs.get('session_id', '')
	self.twitter_keys = kwargs.get('twitter_keys', None)
	self.user_agent = kwargs.get('user_agent', get_agent())
	self.user_map = kwargs.get('user_map', {})
	print('Using default profile.')

New 🥵😩

insta-tweet/InstaTweet/profile.py

Lines 53 to 60 in e317174

	self.local = local
	self.name = name # Will raise Exception if name is already used
	self.session_id = kwargs.get('session_id', '')
	self.twitter_keys = kwargs.get('twitter_keys', TweetClient.DEFAULT_KEYS)
	self.user_agent = kwargs.get('user_agent', utils.get_agent())
	self.proxy_key = kwargs.get('proxy_key', None)
	self.user_map = kwargs.get('user_map', {})

However, it now

• Properly supports multiple save/export (and load) formats; default is pickle
• Supports proxies and saving data remotely in any SQLAlchemy compatible database
• Can switch between local/remote saves via the local property setter
• Has methods to make it simple to modify and access its data
• Has more documentation than code
• Is easier on the eyes and brain

The DBConnection Class

The DBConnection uses SQLAlchemy to query, load, save, and delete remotely saved profiles in the Profiles database table. It was an excuse to try out context management. I won't lie.

• To designate a Profile as remote, just set Profile.local=False

Warning
You MUST configure the DATABASE_URL environment variable before these features can be used

If this would be of interest to you, please see the full documentation of the db module

---

Local vs. Remote?

When you call save() on a Profile, the name is used as a unique identifier to create or update save data in the location specified by local

• Local saves are made to the LOCAL_DIR, as pickle files
• Remote saves are made to a database (via the db module) as pickle bytes

The Profile can be deserialized at a later time by passing the same name and value of local to either Profile.load() or InstaTweet.load()

Since the name of a Profile can be

• Passed as a parameter during initialization
• Set directly as an object attribute after initialization
• Changed during the call to save()

A property setter will always make sure that no profile_exists() with the same name, in the location specified by local

insta-tweet/InstaTweet/profile.py

Lines 271 to 284 in e317174

	@name.setter
	def name(self, profile_name):
	"""Sets the profile name, if a profile with that name doesn't already exist locally/remotely"""
	if profile_name != 'default' and self.profile_exists(profile_name, local=self.local):
	if self.local:
	raise FileExistsError(
	'Local save file already exists for profile named "{}"\n'.format(profile_name) +
	'Please choose another name, load the profile, or delete the file.')
	else:
	raise ResourceWarning(
	'Database record already exists for profile named "{}"\n'.format(profile_name) +
	'Please choose another name or use InstaTweet.db to load/delete the profile'
	)
	self._name = profile_name

insta-tweet/InstaTweet/profile.py

Lines 91 to 98 in e317174

	@staticmethod
	def profile_exists(name: str, local: bool = True) -> bool:
	"""Check if a profile with the given name and location (local/remote) already exists"""
	if local:
	return os.path.exists(Profile.get_local_path(name))
	else:
	with DBConnection() as db:
	return bool(db.query_profile(name).first())

Note
You must load() a saved Profile's settings, as initializing a new one with that name would be considered a duplicate

The New InstaTweet 🐥✨

With the settings out of the way, InstaTweet now focuses on the actual InstaTweeting - the detection and downloading of new Instagram posts, sending of tweets, and [when applicable] the autosaving of its loaded Profile. You would know this if you read the definition above.

Once you've configured a Profile, you can initialize an InstaTweet object in 2 ways:

• If you've saved the Profile, you can load() its settings in by name
  • This same save file will be automatically updated whenever progress is made

insta-tweet/InstaTweet/instatweet.py

Lines 35 to 43 in e317174

	@classmethod
	def load(cls, profile_name: str, local: bool = True) -> "InstaTweet":
	"""Loads a profile by name
	:param profile_name: profile name
	:param local: whether the profile is saved locally (True) or remotely on a SQLAlchemy-supported database
	"""
	return cls(profile=Profile.load(name=profile_name, local=local))

• Otherwise, you can use the Profile to directly initialize InstaTweet; since no save file exists, nothing will be saved during a run

insta-tweet/InstaTweet/instatweet.py

Lines 27 to 40 in c13b6ca

	def __init__(self, profile: Profile):
	"""Initializes InstaTweet using a fully configured :class:`~.Profile`
	The :class:`~.Profile` will be used to initialize an :class:`~.InstaClient` and :class:`~.TweetClient`
	:Note:
	Profile settings will only be validated when calling :meth:`~.start`
	:param profile: the :class:`~.Profile` to use for InstaTweeting
	"""
	self.profile = profile
	self.proxies = self.get_proxies()
	self.insta = self.get_insta_client()
	self.twitter = self.get_tweet_client()

Note
The profile just needs to be configured, it doesn't need to be saved. If you plan to run it
more than once, you should really save it though

Assuming the settings are valid, you can then call start(), just like before

OKAY IM DONE, LIKE I WROTE DOCUMENTATION FOR A REASON ‼

[TDKorn]

ima do this part later lol

say less

[TDKorn]

that's hot