def __follow_user(self, user: User):
"""Function to follow a specific user. It sends the user to the server and then, if the bot doesn't follow the
user, it tries to follow the user. At last, it reads the user's tweets timeline and sends it to the server
:param user: user to follow
"""
logger.info(f"Following user <{user.id}>")
if not user.following:
virtual_read_wait(user.description)
try:
user.follow()
logger.info(f"Followed User with id <{user.id}>")
self.__send_user(user, messages_types.BotToServer.SAVE_USER)
except TweepError as error:
if error.api_code == FOLLOW_USER_ERROR_CODE:
logger.exception(
f"Unable to follow User with id <{user.id}> because of error <{error}>: "
)
else:
logger.exception(
f"Error <{error}> with api_code={error.api_code}: ")
if not user.protected or (user.protected and user.following):
self.__read_timeline(user, jump_users=False)
def __init__(self, user: User):
super().__init__(user=user)
self.name: str = user.__getattribute__("name")
self.url: str = user.__getattribute__("url")
try:
self.profile_banner_url: str = user.__getattribute__(
"profile_banner_url")
except Exception as e:
self.profile_banner_url: str = \
"https://i.picsum.photos/id/1021/2048/1206.jpg?hmac=fqT2NWHx783Pily1V_39ug_GFH1A4GlbmOMu8NWB3Ts"
self.profile_url: str = "https://twitter.com/" + self.screen_name.replace(
"@", "")
self.listed_count: str = user.__getattribute__("listed_count")
self.botometer_analysis: dict = {}
self.uuid: str = self.get_128_uuid(data_str=str(self.id))
def test_get_people_to_follow(
self, mock_cursor, patched_db, mocked_api, all_requests, user_requests, expected
):
"""
This test checks whether 'get_people_to_follow' sorts requests into the right categories
"""
followers = [User(), User()]
mock_cursor.return_value.items.return_value = followers
patched_db.return_value.get_item.side_effect = [
{"count": all_requests},
{"count": user_requests},
]
assert views.get_people_to_follow(mocked_api, "test_id") == (
followers,
expected,
)
def callback(self):
request_token = session.pop('request_token')
if 'oauth_verifier' not in request.args:
return None
oauth_session = self.service.get_auth_session(
request_token[0], request_token[1],
data={'oauth_verifier': request.args['oauth_verifier']}
)
user = User.parse(None,
oauth_session.get('account/verify_credentials.json').json())
key = oauth_session.access_token
secret = oauth_session.access_token_secret
return user, key, secret
def callback(self):
request_token = session.pop('request_token')
if 'oauth_verifier' not in request.args:
return None
oauth_session = self.service.get_auth_session(
request_token[0],
request_token[1],
data={'oauth_verifier': request.args['oauth_verifier']})
user = User.parse(
None,
oauth_session.get('account/verify_credentials.json').json())
key = oauth_session.access_token
secret = oauth_session.access_token_secret
return user, key, secret
def __user_timeline_tweets(self, user: User, **kwargs) -> List[Status]:
"""Function to get the 20 (default) most recent tweets (including retweets) from some user
:param user: user whom tweets we want
:param kwargs: dictionary with keyword arguments. These arguments can be the follows:
- since_id: Returns only statuses with an ID greater than (that is, more recent than) the specified ID
- max_id: Returns only statuses with an ID less than (that is, older than) or equal to the specified ID
- count: Specifies the number of statuses to retrieve
- page: Specifies the page of results to retrieve. Note: there are pagination limits
"""
logger.debug(f"Getting timeline tweets for User with id={user.id}")
if user.id == self.user.id:
try:
return list(self._twitter_api.home_timeline(**kwargs))
except TweepError as error:
self.__send_error_suspended_log(error, str(user.id))
return list(user.timeline(**kwargs))
def parse_follow_unfollow_event(self, data):
"""
if data is follow or unfollow event-object then return parsed event-object,
else return False.
"""
if '"event":"follow"' not in data and '"event":"unfollow"' not in data:
return False
jobj = json.loads(data)
if 'event' not in jobj or 'created_at' not in jobj or 'target' not in jobj:
return False
event_name = jobj['event']
if event_name != 'follow' and event_name != 'unfollow':
return False
target = User.parse(self.api, jobj['target'])
if event_name == 'follow' and target.id == self.my_id: # User is followed
return False
created_at = parse_datetime(jobj['created_at'])
return dict(event_name=event_name, created_at=created_at, target=target)
def parse_status_event(self, data):
"""
if status contains user-object then return parsed user-object,
else return False.
** NOTE **
this method treats tweet and RT,
but other data also contains '"in_reply_to_status_id":', e.g. fav.
"""
if '"in_reply_to_status_id":' not in data:
return False
jobj = json.loads(data)
if 'user' not in jobj or 'created_at' not in jobj:
return False
user = User.parse(self.api, jobj['user'])
if user.id != self.my_id and user.id not in self.friends:
return False
created_at = parse_datetime(jobj['created_at'])
return dict(user=user, created_at=created_at)
def on_data(self, raw_data):
data = json.loads(raw_data)
status = User.parse(self.api, data)
location = status.user['location']
if location == None:
location = 'No Activado'
print(location)
# ------------------#
print(location)
print(status)
# print(status.user['name']+': '+ status.text)
creado = status.created_at
id = status.id
nom = status.user['name']
tweet = status.text
cursor.execute(
'''INSERT INTO USUARIO(ID, NOMBRE, TWEETS, CREADO) VALUES(?,?,?,?)''',
(id, nom, tweet, creado))
db.commit()
return (True)
def mock_get_user_protected(id=None):
mock_twitteruser = TwitterUser()
mock_twitteruser.contributors_enabled = 1
mock_twitteruser.description = 'blogger'
mock_twitteruser.entities = [1, 2, 3]
mock_twitteruser.favourites_count = 1
mock_twitteruser.followers_count = 1
mock_twitteruser.friends_count = 1
mock_twitteruser.geo_enabled = False
mock_twitteruser.is_translator = False
mock_twitteruser.listed_count = 1
mock_twitteruser.protected = True
mock_twitteruser.statuses_count = 1
mock_twitteruser.url = ''
mock_twitteruser.verified = False
mock_twitteruser.screen_name = 'Test2'
mock_twitteruser.id = 2
mock_twitteruser.lang = 'en'
return mock_twitteruser
def __init__(self, user: User):
self.created_at: str = preprocess_date(
user.__getattribute__("created_at"))
self.default_profile: bool = user.__getattribute__("default_profile")
self.default_profile_image: bool = user.__getattribute__(
"default_profile_image")
self.favourites_count: int = user.__getattribute__("favourites_count")
self.followers_count: int = user.__getattribute__("followers_count")
self.friends_count: int = user.__getattribute__("friends_count")
self.geo_enabled: bool = user.__getattribute__("geo_enabled")
self.id: int = user.__getattribute__("id")
self.lang: str = self.get_language(
text=user.__getattribute__("description"))
self.location: str = "N/A" if user.__getattribute__(
"location") is None or user.__getattribute__(
"location") == "" else user.__getattribute__("location")
self.statuses_count: int = user.__getattribute__("statuses_count")
self.profile_background_image_url: str = user.__getattribute__(
"profile_background_image_url")
self.profile_image_url: str = user.__getattribute__(
"profile_image_url")
self.screen_name: str = user.__getattribute__("screen_name")
self.verified: bool = user.__getattribute__("verified")
self.average_tweets_per_day: float = get_average_tweets_per_day(
statuses_count=self.statuses_count,
created_at=user.__getattribute__("created_at"))
self.account_age_days: int = get_account_age_in_days(
created_at=user.__getattribute__("created_at"))
self.botometer_analysis: dict = {}
self.uuid: str = self.get_128_uuid(data_str=str(self.id))
def me(self):
return User.parse(self, fewerror_user)
def on_data(self, raw_data):
data = json.loads(raw_data)
status = User.parse(self.api, data)
tweet = status.text
print(tweet)
return (True)