The user ID of the user who owns the list being requested by a slug.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self,
list_id=None,
slug=None,
user_id=None,
screen_name=None,
owner_screen_name=None,
owner_id=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
list_id -> int
slug -> string
user_id -> int
screen_name -> string
owner_screen_name -> string
owner_id -> int'''
# encapsulate namespace
members = AbstractModule(globals())
# enforce singleton
del (destroy, create_all, show, create, destroy_all, Ternary, AbstractModule,
post, get)
try:
from twitter.application.api.superclass.abstract_module import AbstractModule
from twitter.application.api._mutes.users import users
except ModuleNotFoundError as main:
from application.api.superclass.abstract_module import AbstractModule
from application.api._mutes.users import users
# encapsulate namespace
mutes = AbstractModule(globals())
setattr(mutes, 'users', users)
# enforce singleton
del (users, AbstractModule)
- lat
If provided with a long parameter the available trend locations will be
sorted by distance, nearest to furthest, to the co-ordinate pair. The valid
ranges for longitude is -180.0 to +180.0 (West is negative, East is
positive) inclusive.
- long
If provided with a lat parameter the available trend locations will be
sorted by distance, nearest to furthest, to the co-ordinate pair. The valid
ranges for longitude is -180.0 to +180.0 (West is negative, East is
positive) inclusive.'''
def __init__(self):
super().__init__()
self._method = get
def __call__(self, lat=None, long=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
lat -> -90 <= int <= 90
long -> -180 <= int <= 180'''
# encapsulate namespace
trends = AbstractModule(globals())
# enforce singleton
del (place, available, closest, AbstractBase, AbstractModule, Empty, get)
- image
The base64-encoded file content being uploaded.
- additional_owners
A comma-separated list of user IDs to set as additional owners allowed to
use the returned media_id in Tweets or Cards. Up to 100 additional owners
may be specified.'''
def __init__(self):
super().__init__()
def __call__(self, image=None, additional_owners=None):
self._data = {'media_data': base64encode({'image': image})['image']}
del image
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
image -> abspath to jpg, gif, or png
additional_owners -> comma separated list of user ids'''
# encapsulate namespace
media = AbstractModule(globals())
# TODO
###### setattr(media, 'multipart', multipart)
# enforce singleton
del (upload, Media, AbstractBase, AbstractModule, get, post)
long=None,
query=None,
ip=None,
granularity=None,
accuracy=None,
max_results=None,
contained_within=None,
street_address=None,
callback=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
lat -> -90 <= float <= 90
long -> -180 <= float <= 180
query -> string, name
ip -> ip address
granularity -> str in {'poi', 'neighborhood', 'city', 'admin', 'country'}
accuracy -> int, or a numeric string postfixed with 'ft'
max_results -> int
contained_within -> place_id string
street_address -> string
callback -> string'''
# encapsulate namespace
geo = AbstractModule(globals())
# enforce singleton
del (id, reverse_geocode, search, AbstractBase, AbstractModule, Numeric, get)
authenticating user must be the recipient of the specified direct message.
Direct Messages are only removed from the interface of the user context
provided. Other members of the conversation can still access the Direct
Messages. A successful delete will return a 204 http response code with no body
content.
Important: This method requires an access token with RWD (read, write & direct
message) permissions.
- id
The id of the Direct Message event that should be deleted.'''
def __init__(self):
super().__init__()
self._method = delete
def __call__(self, id=None):
return super().__call__(**filter(**vars(
)))
def __repr__(self):
return '''PARAMETERS
id -> int; msg id'''
# encapsulate namespace
events = AbstractModule(globals())
# enforce singleton
del (show, new, List, destroy,
AbstractModule, Ternary, get, post, delete)
- recipient_id
The user ID of the user to receive the typing indicator.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self, recipient_id=None):
super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
recipient_id -> int; user id'''
# encapsulate namespace
direct_messages = AbstractModule(globals())
#setattr(direct_messages, 'welcome_messages', welcome_messages)
setattr(direct_messages, 'events', events)
# enforce singleton
del (
mark_read,
indicate_typing,
events, #welcome_messages,
AbstractBase,
AbstractModule,
get,
post,
delete)
def __repr__(self):
return '''PARAMETERS
query -> len(string) <= 100'''
class destroy(Numeric):
'''Destroys a saved search for the authenticating user. The authenticating
user must be the owner of saved search id being destroyed.
- id
The ID of the saved search.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self, id=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
id -> int'''
# encapsulate namespace
saved_searches = AbstractModule(globals())
# enforce singleton
del (List, create, destroy, show, Numeric, Empty, AbstractBase, AbstractModule,
post, get)
with height, width, and offset_left to select the desired region of the
image to use.'''
def __init__(self):
super().__init__()
self._key = 'banner'
def __call__(self, banner=None, width=None, height=None, offset_left=None,
offset_top=None):
return super().__call__(**filter(**vars(
)))
def __repr__(self):
return ''' PARAMETERS
banner -> image file abspath/location
width -> pos int; width of preferred section of the img, in pixels
height -> height of the preferred section.
offset_left -> num of px by which to offset the image from the left
offset_top -> num px to offset the uploaded image from the top.'''
# encapsulate namespace
account = AbstractModule(globals())
# enforce singleton
del (settings, verify_credentials, update_settings,
update_profile, update_profile_image, remove_profile_banner,
update_profile_banner,
AbstractBase, AbstractModule, Empty,
Base64, get, post)
class remove(Ternary):
'''Remove the specified Tweet from a Collection.
Use POST collections / entries / curate to remove Tweets from a Collection in
bulk.
- id
The identifier of the target Collection.
- tweet_id
The identifier of the Tweet to remove.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self, id=None, tweet_id=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
id -> string
tweet_id -> int'''
# encapsulate namespace
entries = AbstractModule(globals())
# enforce singleton
del (add, curate, move, remove, AbstractModule, Ternary, delete, post, get)
self._method = get
def __call__(self, resources=None):
if self.twitter.CACHE_LOCKED:
# caching is off or we are updating the cache
return super().__call__()
elif not bool(self.twitter.cache) or self.twitter.cache.expired:
# the cache does not exist or the cache is expired
# create a new cache
try:
self.twitter.cache.refresh(self)
except CacheError as a_problem:
self.twitter.log.debug(a_problem)
try:
return self.twitter.cache[resources]
except KeyError as update:
return self.twitter.cache
def __repr__(self):
return ''' PARAMETERS
resources -> a comma-seperated list of resource families'''
# encapsulate namespace
application = AbstractModule(globals())
# enforce singleton
del rate_limit_status, AbstractBase, AbstractModule, get
Returns the liked status when successful.
This process invoked by this method is asynchronous. The immediately returned
status may not indicate the resultant liked status of the tweet. A 200 OK
response from this method will indicate whether the intended action was
successful or not.
- id
The numerical ID of the desired status.
- include_entities
The entities node will be omitted when set to false.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self, id=None, include_entities=False):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
id -> int; status id
include_entities -> bool'''
# encapsulate namespace
favorites = AbstractModule(globals())
# enforce singleton
del (List, destroy, create, AbstractBase, AbstractModule, post, get)
- name
The title of the Collection being created, in 25 characters or fewer.
- description
A brief description of this Collection in 160 characters or fewer.
- url
A fully-qualified URL to associate with this Collection.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self, id=None, name=None, description=None, url=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
id -> string
name -> string
description -> string
url -> string'''
# encapsulate
collections = AbstractModule(globals())
setattr(collections, 'entries', entries)
# enforce singleton
del (entries, List, show, create, destroy, entries_endpoint, AbstractBase,
AbstractModule, Collision, post, get)
- include_user_entities
The user object entities node will not be included when set to false.'''
def __init__(self):
super().__init__()
self._method = get
def __call__(self,
user_id=None,
screen_name=None,
cursor=None,
count=20,
skip_status=False,
include_user_entities=False):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
user_id -> int
screen_name -> string
cursor -> string
count -> int
skip_status -> bool
include_user_entities -> bool'''
# encapsulate namespace
followers = AbstractModule(globals())
# enforce singleton
del (ids, List, AbstractBase, AbstractModule, get)
- map
When using the map parameter, tweets that do not exist or cannot be viewed
by the current user will still have their key represented but with an
explicitly null value paired with it'''
def __init__(self):
super().__init__()
self._method = get
def __call__(self,
id=None,
include_entities=False,
trim_user=False,
map=False):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''
id -> csv list of tweet IDs; max 100 entries
include_entities -> bool
trim_user -> true, t or 1
map -> bool'''
# encapsulate namespace
statuses = AbstractModule(globals())
# enforce singleton
del (mentions_timeline, user_timeline, home_timeline, retweets_of_me, retweets,
show, destroy, update, retweet, unretweet, oembed, retweeters, lookup,
AbstractBase, AbstractModule, Numeric, get, post)
Provide values as returned in the response body’s next_cursor and
previous_cursor attributes to page back and forth in the list. It is
recommended to always use cursors when the method supports them. See
[node:10362] for more information.'''
def __init__(self):
super().__init__()
self._method = get
def __call__(self, user_id=None, screen_name=None, count=20, cursor=None):
return super().__call__(**filter(**vars(
)))
def __repr__(self):
return '''PARAMETERS
user_id -> int
screen_name -> string
count -> int <= 1000
cursor -> string'''
# encapsulate namespace
lists = AbstractModule(globals())
setattr(lists, 'members', members)
setattr(lists, 'subscribers', subscribers)
# enforce singleton
del (List, statuses, memberships, subscribers_endpoint, members_endpoint, destroy, update, create,
show, subscriptions, ownerships, members, subscribers,
AbstractBase, AbstractModule, Collision, post, get)
connections can be: following, following_requested, followed_by, none, blocking,
muting.
- screen_name
A comma separated list of screen names, up to 100 are allowed in a single
request.
- user_id
A comma separated list of user IDs, up to 100 are allowed in a single
request.'''
def __init__(self):
super().__init__()
self._method = get
def __call__(self, screen_name=None, user_id=None):
return super().__call__(**filter(**vars(
)))
def __repr__(self):
return '''PARAMETERS
screen_name -> string
user_id -> int'''
# encapsulate namespace
friendships = AbstractModule(globals())
# enforce singleton
del (no_retweets, incoming, outgoing, create, destroy, update, show, lookup,
AbstractBase, AbstractModule, post, get)
self._url = url
return response
def __repr__(self):
return '''PARAMETERS
slug -> string
lang -> two letter ISO 639-1 specification'''
class members(slug):
'''Access the users in a given category of the Twitter suggested user list
and return their most recent status if they are not a protected user.
- slug
The short name of list or a category'''
def __init__(self):
super().__init__()
self._method = get
self._url = self.url.replace('.json', '/members.json')
self._endpoint += '/members'
def __call__(self, slug=None):
return super().__call__(**filter(**vars(
)))
def __repr__(self):
return '''PARAMETERS
slug -> string'''
suggestions = AbstractModule(globals())
- owner_screen_name
The screen name of the user who owns the list being requested by a slug.
- owner_id
The user ID of the user who owns the list being requested by a slug.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self,
list_id=None,
slug=None,
owner_screen_name=None,
owner_id=None):
return super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
list_id -> int
slug -> string
owner_screen_name -> string
owner_id -> int'''
# encapsulate namespace
subscribers = AbstractModule(globals())
# enforce singleton
del (create, destroy, show, Ternary, AbstractModule, post, get)
The entities node will not be included when set to false.
- skip_status
When set to either true, t or 1 statuses will not be included in the
returned user objects.'''
def __init__(self):
super().__init__()
self._method = post
def __call__(self,
screen_name=None,
user_id=None,
include_entities=True,
skip_status=False):
super().__call__(**filter(**vars()))
def __repr__(self):
return '''PARAMETERS
screen_name -> string
user_id -> int; twitter user id
include_entities -> bool
skip_status -> bool'''
# encapsulate namespace
blocks = AbstractModule(globals())
# enforce singleton
del (List, ids, create, destroy, AbstractBase, AbstractModule, get, post)