def retrieve_words(request): frob = request.GET.get('frob') api = Rtm(settings.RTM_API_KEY, settings.RTM_API_SECRET, "read", None) api.retrieve_token(frob) if not api.token_valid(): raise ValueError("not a valid token") result = api.rtm.tasks.getList(list_id=settings.RTM_WORD_LIST_ID) flashcards = [] quotes = [] for tasklist in result.tasks: for taskseries in tasklist: parts = taskseries.name.split(':') if len(parts) == 1: quotes.append(''.join(parts)) if len(parts) > 1: flashcards.append((parts[0], ':'.join(parts[1:]))) context = { "rtw_data": json.dumps({ "flashcards": flashcards, "quotes": quotes }), "api_token": api.token, } return render(request, 'rtw.html', context=context)
def retrieve_words(request): frob = request.GET.get('frob') api = Rtm(settings.RTM_API_KEY, settings.RTM_API_SECRET, "read", None) api.retrieve_token(frob) if not api.token_valid(): raise ValueError("not a valid token") result = api.rtm.tasks.getList(list_id=settings.RTM_WORD_LIST_ID) flashcards = [] quotes = [] for tasklist in result.tasks: for taskseries in tasklist: parts = taskseries.name.split(':') if len(parts) == 1: quotes.append(''.join(parts)) if len(parts) > 1: flashcards.append((parts[0], ':'.join(parts[1:]))) context = { "rtw_data": json.dumps({"flashcards": flashcards, "quotes": quotes}), "api_token": api.token, } return render(request, 'rtw.html', context=context)
def connect(api_key=None, shared_secret=None, token=None, frob=None): api_key = api_key or os.environ.get("RTM_KEY") shared_secret = shared_secret or os.environ.get("RTM_SECRET") token = token or os.environ.get("RTM_TOKEN") if not api_key or not shared_secret or not (token or frob): raise ValueError( "Expected an API key, app secret, and either a token or frob.") api = Rtm(api_key, shared_secret, "delete", token) if frob: api.retrieve_token(frob) print("New token: ", api.token) else: # authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): md5 = hashlib.md5() md5.update("{secret}api_key{key}permsdelete".format( secret=shared_secret, key=api_key)) api_sig = md5.hexdigest() generate_frob_url = _generate_frob_url(api_key, shared_secret) raise ValueError( "An invalid token was provided. Try generating a new frob in the browser by visiting {}" .format(generate_frob_url)) return api
def main(): api_key = "910f700cc0ff23ed2462312c250bc560" shared_secret = "b7be4d2a824b42b1" token = sys.argv[2] if len(sys.argv) == 3 else None task_name = sys.argv[1] api = Rtm(api_key, shared_secret, "delete", token) if not api.token_valid(): url, frob = api.authenticate_desktop() webbrowser.open(url) input("Continue?") # Get the token for the frob assert (api.retrieve_token(frob)) print("New token: {}".format(api.token)) result = api.rtm.timelines.create() timeline = result.timeline.value # Add task - default is Inbox result = api.rtm.tasks.add(timeline=timeline, parse="1", name=task_name) task_id = result.list.taskseries.id print("Create task, id: {}".format(task_id))
def __init__(self, name, api_key, shared_secret, token, rtm_config): """Create new instance of Remember The Milk component.""" self._name = name self._api_key = api_key self._shared_secret = shared_secret self._token = token self._rtm_config = rtm_config self._rtm_api = Rtm(api_key, shared_secret, "delete", token) self._token_valid = None self._check_token() _LOGGER.debug("Instance created for account %s", self._name)
def index(request): context = {"DEBUG": settings.DEBUG} api = Rtm(settings.RTM_API_KEY, settings.RTM_API_SECRET, "read", None) if not api.token_valid(): # use desktop-type authentication auth_url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application context['auth_url'] = auth_url context['auth_frob'] = frob return render(request, 'index.html', context=context)
def index(request): context = {"DEBUG": settings.DEBUG} api = Rtm(settings.RTM_API_KEY, settings.RTM_API_SECRET, "read", None) if not api.token_valid(): # use desktop-type authentication auth_url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application context['auth_url'] = auth_url context['auth_frob'] = frob return render(request, 'index.html', context=context)
def _register_new_account( hass, account_name, api_key, shared_secret, stored_rtm_config, component ): request_id = None configurator = hass.components.configurator api = Rtm(api_key, shared_secret, "write", None) url, frob = api.authenticate_desktop() _LOGGER.debug("Sent authentication request to server") def register_account_callback(_): """Call for register the configurator.""" api.retrieve_token(frob) token = api.token if api.token is None: _LOGGER.error("Failed to register, please try again") configurator.notify_errors( request_id, "Failed to register, please try again." ) return stored_rtm_config.set_token(account_name, token) _LOGGER.debug("Retrieved new token from server") _create_instance( hass, account_name, api_key, shared_secret, token, stored_rtm_config, component, ) configurator.request_done(request_id) request_id = configurator.async_request_config( f"{DOMAIN} - {account_name}", callback=register_account_callback, description=( "You need to log in to Remember The Milk to" "connect your account. \n\n" "Step 1: Click on the link 'Remember The Milk login'\n\n" "Step 2: Click on 'login completed'" ), link_name="Remember The Milk login", link_url=url, submit_caption="login completed", )
def retrieve_tasks(): print("Running job") # with open("config.yaml", 'r') as stream: # cfg = yaml.load(stream) with open('event.json') as data_file: cfg = json.load(data_file) api_key = cfg['rtm_api_key'] shared_secret = cfg['rtm_shared_secret'] token = cfg['rtm_token'] api = Rtm(api_key, shared_secret, "delete", token) # authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): print("got an invalid token", api) return # get all open tasks, see # http://www.rememberthemilk.com/services/api/methods/rtm.tasks.getList.rtm yesterdays_list = api.rtm.tasks.getList(filter="completed:yesterday") yesterdays = [] for tasklist in yesterdays_list.tasks: for taskseries in tasklist: print(taskseries.task.due, taskseries.name) yesterdays.append(taskseries) # for 3am tasks, may be an issue if it runs during the day yesterdays_extended_list = api.rtm.tasks.getList(filter="completed:today") for tasklist in yesterdays_extended_list.tasks: for taskseries in tasklist: print(taskseries.task.due, taskseries.name) yesterdays.append(taskseries) todays_list = api.rtm.tasks.getList(filter="dueBefore:tomorrow") todays = [] for tasklist in todays_list.tasks: for taskseries in tasklist: if taskseries.task.completed == "": print(taskseries.task.due, taskseries.name) todays.append(taskseries) process_tasks(todays, yesterdays)
def _register_new_account(hass, account_name, api_key, shared_secret, stored_rtm_config, component): from rtmapi import Rtm request_id = None configurator = hass.components.configurator api = Rtm(api_key, shared_secret, "write", None) url, frob = api.authenticate_desktop() _LOGGER.debug("Sent authentication request to server") def register_account_callback(_): """Call for register the configurator.""" api.retrieve_token(frob) token = api.token if api.token is None: _LOGGER.error("Failed to register, please try again") configurator.notify_errors( request_id, 'Failed to register, please try again.') return stored_rtm_config.set_token(account_name, token) _LOGGER.debug("Retrieved new token from server") _create_instance( hass, account_name, api_key, shared_secret, token, stored_rtm_config, component) configurator.request_done(request_id) request_id = configurator.async_request_config( '{} - {}'.format(DOMAIN, account_name), callback=register_account_callback, description='You need to log in to Remember The Milk to' + 'connect your account. \n\n' + 'Step 1: Click on the link "Remember The Milk login"\n\n' + 'Step 2: Click on "login completed"', link_name='Remember The Milk login', link_url=url, submit_caption="login completed", )
def _register_new_account(hass, account_name, api_key, shared_secret, stored_rtm_config, component, descriptions): from rtmapi import Rtm request_id = None configurator = hass.components.configurator api = Rtm(api_key, shared_secret, "write", None) url, frob = api.authenticate_desktop() _LOGGER.debug('sent authentication request to server') def register_account_callback(_): """Callback for configurator.""" api.retrieve_token(frob) token = api.token if api.token is None: _LOGGER.error('Failed to register, please try again.') configurator.notify_errors( request_id, 'Failed to register, please try again.') return stored_rtm_config.set_token(account_name, token) _LOGGER.debug('retrieved new token from server') _create_instance( hass, account_name, api_key, shared_secret, token, stored_rtm_config, component, descriptions) configurator.request_done(request_id) request_id = configurator.async_request_config( '{} - {}'.format(DOMAIN, account_name), callback=register_account_callback, description='You need to log in to Remember The Milk to' + 'connect your account. \n\n' + 'Step 1: Click on the link "Remember The Milk login"\n\n' + 'Step 2: Click on "login completed"', link_name='Remember The Milk login', link_url=url, submit_caption="login completed", )
def getTheCategoriesListStatically(apiKey, sharedSecret): ''' This method uses the RTM service by instantiating a new RTM object and tries to retrieve the list of listnames from the service. It can be run independently, as it uses an extra instance of the RTM object ''' listsNames = [] tokenManager = TokenManager() token = tokenManager.readTokenFromFile() if (token is None): # If the token doesn't exist, it won't work return listsNames rtm = Rtm(apiKey, sharedSecret, "read", token) if not rtm.token_valid(): # The token wasn't vaid return listsNames # Get the lists description, see http://www.rememberthemilk.com/services/api/methods/rtm.lists.getList.rtm listsList = rtm.rtm.lists.getList() # Get the name of each list for element in listsList.lists: listsNames.append(element.name) return listsNames
def getTheCategoriesListStatically(apiKey, sharedSecret): ''' This method uses the RTM service by instantiating a new RTM object and tries to retrieve the list of listnames from the service. It can be run independently, as it uses an extra instance of the RTM object ''' listsNames = [] tokenManager = TokenManager() token = tokenManager.readTokenFromFile() if (token is None): # If the token doesn't exist, it won't work return listsNames rtm = Rtm(apiKey, sharedSecret, "read", token) if not rtm.token_valid(): # The token wasn't vaid return listsNames # Get the lists description, see http://www.rememberthemilk.com/services/api/methods/rtm.lists.getList.rtm listsList = rtm.rtm.lists.getList() # Get the name of each list for element in listsList.lists: listsNames.append(element.name) return listsNames
def __init__(self): super(TasksLens, self).__init__() # Object to manage RTM lists self._listsInfoManager = ListsInfoManager() # Object to manage RTM tasks self._tasksInfoManager = TasksInfoManager(self._listsInfoManager) # Object to handle the token (save to file, read from file) self._tokenManager = TokenManager() # RTM auth manager object self._authManager = AuthManager(ICON + ICON_EXTENSION, self.tasks) # RTM auth token self._token = self._tokenManager.readTokenFromFile() # RTM object self._rtm = Rtm(RAK, RSS, "read", self._token)
def __init__(self, api_key: str, api_secret: str, token: str) -> None: self.api = Rtm(api_key, api_secret, token=token) self.timeline = self.api.rtm.timelines.create().timeline.value
class RememberTheMilk(Entity): """Representation of an interface to Remember The Milk.""" def __init__(self, name, api_key, shared_secret, token, rtm_config): """Create new instance of Remember The Milk component.""" self._name = name self._api_key = api_key self._shared_secret = shared_secret self._token = token self._rtm_config = rtm_config self._rtm_api = Rtm(api_key, shared_secret, "delete", token) self._token_valid = None self._check_token() _LOGGER.debug("Instance created for account %s", self._name) def _check_token(self): """Check if the API token is still valid. If it is not valid any more, delete it from the configuration. This will trigger a new authentication process. """ valid = self._rtm_api.token_valid() if not valid: _LOGGER.error( "Token for account %s is invalid. You need to register again!", self.name, ) self._rtm_config.delete_token(self._name) self._token_valid = False else: self._token_valid = True return self._token_valid def create_task(self, call): """Create a new task on Remember The Milk. You can use the smart syntax to define the attributes of a new task, e.g. "my task #some_tag ^today" will add tag "some_tag" and set the due date to today. """ try: task_name = call.data.get(CONF_NAME) hass_id = call.data.get(CONF_ID) rtm_id = None if hass_id is not None: rtm_id = self._rtm_config.get_rtm_id(self._name, hass_id) result = self._rtm_api.rtm.timelines.create() timeline = result.timeline.value if hass_id is None or rtm_id is None: result = self._rtm_api.rtm.tasks.add( timeline=timeline, name=task_name, parse="1" ) _LOGGER.debug( "Created new task '%s' in account %s", task_name, self.name ) self._rtm_config.set_rtm_id( self._name, hass_id, result.list.id, result.list.taskseries.id, result.list.taskseries.task.id, ) else: self._rtm_api.rtm.tasks.setName( name=task_name, list_id=rtm_id[0], taskseries_id=rtm_id[1], task_id=rtm_id[2], timeline=timeline, ) _LOGGER.debug( "Updated task with id '%s' in account %s to name %s", hass_id, self.name, task_name, ) except RtmRequestFailedException as rtm_exception: _LOGGER.error( "Error creating new Remember The Milk task for account %s: %s", self._name, rtm_exception, ) return False return True def complete_task(self, call): """Complete a task that was previously created by this component.""" hass_id = call.data.get(CONF_ID) rtm_id = self._rtm_config.get_rtm_id(self._name, hass_id) if rtm_id is None: _LOGGER.error( "Could not find task with ID %s in account %s. " "So task could not be closed", hass_id, self._name, ) return False try: result = self._rtm_api.rtm.timelines.create() timeline = result.timeline.value self._rtm_api.rtm.tasks.complete( list_id=rtm_id[0], taskseries_id=rtm_id[1], task_id=rtm_id[2], timeline=timeline, ) self._rtm_config.delete_rtm_id(self._name, hass_id) _LOGGER.debug( "Completed task with id %s in account %s", hass_id, self._name ) except RtmRequestFailedException as rtm_exception: _LOGGER.error( "Error creating new Remember The Milk task for account %s: %s", self._name, rtm_exception, ) return True @property def name(self): """Return the name of the device.""" return self._name @property def state(self): """Return the state of the device.""" if not self._token_valid: return "API token invalid" return STATE_OK
from rtmapi import Rtm HABITICA_API = 'https://habitica.com/api/v3/' TASKS_URL = '{}tasks/user'.format(HABITICA_API) TODOS_URL = '{}?type=todos'.format(TASKS_URL) COMPLETED_TODOS_URL = '{}?type=completedTodos'.format(TASKS_URL) if __name__ == '__main__': config = ConfigObj('rtmhabit.ini') rtm = config['rtm'] habitica = config['habitica'] to_sync = rtm['to_sync'] cache = ConfigObj('.cache', create_empty=True) api = Rtm(rtm['api_key'], rtm['shared_secret'], 'delete', cache.get('token')) # authentication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application webbrowser.open(url) input('Continue?') # get the token for the frob api.retrieve_token(frob) # store the new token, should be used to initialize the Rtm object next time cache['token'] = api.token cache.write()
import sys import webbrowser from rtmapi import Rtm if __name__ == '__main__': # call the program as `listtasks.py api_key shared_secret [optional: token]` # get those parameters from http://www.rememberthemilk.com/services/api/keys.rtm api_key, shared_secret = sys.argv[1:3] token = sys.argv[3] if len(sys.argv) >= 4 else None api = Rtm(api_key, shared_secret, "delete", token) # authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application webbrowser.open(url) raw_input("Continue?") # get the token for the frob api.retrieve_token(frob) # print out new token, should be used to initialize the Rtm object next time # (a real application should store the token somewhere) print "New token: %s" % api.token # get all open tasks, see http://www.rememberthemilk.com/services/api/methods/rtm.tasks.getList.rtm result = api.rtm.tasks.getList(filter="status:incomplete") for tasklist in result.tasks: for taskseries in tasklist: print taskseries.task.due, taskseries.name
def workhorse(): signal.signal(signal.SIGINT, quitter) # put the api token and secret in the credentials file (chmod 600) # get those parameters from http://www.rememberthemilk.com/services/api/keys.rtm debug = True if (len(sys.argv) > 1 and sys.argv[1] == 'debug') else False colourtest = True if (len(sys.argv) > 1 and sys.argv[1] == 'colourtest') else False config = configparser.ConfigParser() # test for file presence # if not there, exit telling user to rename template to file and get api key ## TODO: implement previous comment config.read_file(open('rtmstatus.conf')) # test for config items existing if (not config.has_option('main', 'api_key') or not config.has_option('main', 'shared_secret')): # without api_key or shared_secret, I cannot do anything, so exit and tell user to get an API key print ('You need to get a RTM API key and shared secret to use this script.') # exiting with an error code because the script cannot run sys.exit(1) # if token isn't there then launch API without it so we can get one and store it, else launch anyway. if config.has_option('main','token'): api = Rtm(config.get('main', 'api_key'), config.get('main', 'shared_secret'), 'read', config.get('main', 'token')) else: api = Rtm(config.get('main', 'api_key'), config.get('main', 'shared_secret'), 'read', None) # authentication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application webbrowser.open(url) input("Continue?") # get the token for the frob api.retrieve_token(frob) # If the token turns out to be invalid, we get a valid one and store it. config.set('main','token',api.token) with open('rtmstatus.conf', 'w') as configfile: config.write(configfile) # TODO test that this worked # reinitialize the Rtm object del api api = Rtm(config.get('main', 'api_key'), config.get('main', 'shared_secret'), 'read', config.get('main', 'token')) display.connect() display.display_on() print('Press Ctrl+C to quit') while True: backlight = config.get('main', 'defaultcolour') count = {} sections = config.sections() sections.sort(reverse=True) for section in sections: if section != 'main': count[section] = taskcounter(config.get(section, 'filter'), api) display.clear() for section in sections: if section != 'main': display.set_cursor_position(int(config.get(section,'x')),int(config.get(section,'y'))) if int(count[section]) < 10: display.write(config.get(section,'label') + ': ' + str(count[section])) else: display.write(config.get(section,'label') + ':' + str(count[section])) if (int(count[section]) > int(config.get(section,'threshold'))): backlight = config.get(section, 'colour') rgb = backlight.split(',') display.set_backlight_rgb(int(rgb[0]),int(rgb[1]),int(rgb[2])) time.sleep(float(config.get('main','polling_delay')))
#!/usr/bin/python # -*- coding: UTF-8 -*- # Grab just items due today and print them out # Written by Alan McNeil <*****@*****.**> # MIT license. from __future__ import print_function import rtm_const import sys import webbrowser from rtmapi import Rtm from Adafruit_Thermal import * if __name__ == '__main__': api = Rtm(rtm_const.api_key, rtm_const.shared_secret, "read", rtm_const.token) # authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application print ("URL you need to open: %s" % url) webbrowser.open(url) raw_input("Continue?") # get the token for the frob api.retrieve_token(frob) # print out new token, should be used to initialize the Rtm object next time print ("token: %s" % api.token) f1=open('./rtm_const', 'w+') f1.write("token: %s\n" % api.token) print ("You're going to need to remove the duplicate token line\n")
from datetime import date from datetime import timedelta import sys import webbrowser from rtmapi import Rtm API_KEY="e9e716aa8dfd1204538df16585484ba2" SHARED_SECRET="5d84e9d9317ac7d7" TOKEN="3c4fcf60ed866d0a85d9c6460294ac4d3bd11deb" READING_LIST="36739788" WORK_LIST="22205173" if __name__ == '__main__': # call the program as `listtasks.py api_key shared_secret [optional: token]` # get those parameters from http://www.rememberthemilk.com/services/api/keys.rtm api = Rtm(API_KEY, SHARED_SECRET, "delete", TOKEN) # authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # check for valid token if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application webbrowser.open(url) raw_input("Continue?") # get the token for the frob api.retrieve_token(frob) # print out new token, should be used to initialize the Rtm object next time # (a real application should store the token somewhere) print "New token: %s" % api.token
def main(raw_args=None): # Check the arguments passed to this script parser = argparse.ArgumentParser( description='Get a random TO DO from Remember the Milk!', prefix_chars='-/', epilog= 'Note that multiple flags are ANDed together making your search more specific. See docs for more info.' ) parser.add_argument('--loglevel', dest='loglevel', metavar='', choices=['debug'], type=str.lower, help="[optional] Set the log level (e.g. debug, etc.)") parser.add_argument( '-l', '--list', metavar='', help= "[optional] Select a specific list to search in. Use quotes if your list name has spaces in it." ) parser.add_argument( '-t', '--tag', metavar='', help="[optional] Select a specific tag to add to your search filter.") parser.add_argument( '-p', '--priority', metavar='', choices=['1', '2', '3', 'N'], help= "[optional] Select a specific priority to add to your search filter.") args = parser.parse_args(raw_args) # Set loglevel if --loglevel argument is used, otherwise set to INFO if args.loglevel is None: logging_num_level = 20 else: logging_num_level = getattr(logging, args.loglevel.upper()) LOG_FORMAT = "\n %(levelname)s: %(message)s" logging.basicConfig(level=logging_num_level, format=LOG_FORMAT) logging.debug("Args passed in are: " + str(args)) rtm_list = args.list rtm_tag = args.tag rtm_priority = args.priority # Look for a token in ~/.rtm_auth_token first user_home_dir = os.path.expanduser("~") rtm_auth_file = os.path.join(user_home_dir, '.rtm_auth_token') if os.path.exists(rtm_auth_file): with open(rtm_auth_file, "r") as f: token = f.readline() else: token = None # Create a class instance using the RtmAPI module api = Rtm(api_key, shared_secret, "read", token, api_version=2) # Authenication block, see http://www.rememberthemilk.com/services/api/authentication.rtm # Check for valid token. If none, open a browser so the user can authenticate. if not api.token_valid(): # use desktop-type authentication url, frob = api.authenticate_desktop() # open webbrowser, wait until user authorized application webbrowser.open(url) raw_input("Continue?") # get the token for the frob api.retrieve_token(frob) # print out new token, should be used to initialize the Rtm object next time # (a real application should store the token somewhere) logging.debug("New token: %s" % api.token) # Write out the token to the user's home directory f = open(rtm_auth_file, "w") f.write(api.token) f.close() # Get all incomplete tasks based on the constructed filter. # RTM filters: https://www.rememberthemilk.com/help/?ctx=basics.search.advanced filter = 'status:incomplete isSubtask:false' if rtm_list: filter = filter + ' list:"%s"' % rtm_list if rtm_tag: filter = filter + ' tag:"%s"' % rtm_tag if rtm_priority: filter = filter + ' priority:"%s"' % rtm_priority logging.debug("filter is now: " + filter) result = api.rtm.tasks.getList(filter="%s" % filter) list_of_tasks = [] # Use the RtmAPI tasks iter to put the filtered set of tasks into a list for tasklist in result.tasks: for taskseries in tasklist: list_of_tasks.append(taskseries.name) # If the total # of retrieved tasks is zero, print mesg & exit if not list_of_tasks: print "\n\tSorry, but your filter didn't find any to dos." print "\tPerhaps re-check your spelling and try again.\n" exit(0) # Pick out a random task name random_task_name = random.choice(list_of_tasks) logging.debug("Random task name is: " + random_task_name) # Use the random task's name to retrieve its full info result = "" result = api.rtm.tasks.getList(filter='name:"%s"' % random_task_name) logging.debug("results.tasks has a type of: " + str(type(result.tasks))) # Use the RtmAPI iterators to drill down to the taskseries & task info. # To better understand what's going on here, you'll need to read the # RtmAPI docs as well as how Remember The Milk's API returns queries. first_tasklist = iter(result.tasks).next() logging.debug("tasklist has a type of: " + str(type(tasklist))) first_taskseries = iter(first_tasklist).next() logging.debug("first_taskseries type is: " + str(type(first_taskseries))) spinner() # Cosmetic only ;-) print "\nTask Name: \t", COLORAMA_STYLE, COLORAMA_BG, COLORAMA_FG, first_taskseries.name, Style.RESET_ALL if "N" in first_taskseries.task.priority: print 'Priority: \t', COLORAMA_STYLE, COLORAMA_BG, COLORAMA_FG, 'None', Style.RESET_ALL else: print 'Priority: \t', COLORAMA_STYLE, COLORAMA_BG, COLORAMA_FG, first_taskseries.task.priority, Style.RESET_ALL if first_taskseries.task.due == '': print 'Due: \t\t -' else: formatted_date = strftime( strptime(first_taskseries.task.due, "%Y-%m-%dT%H:%M:%SZ"), "%d %b %Y") print 'Due: \t\t', COLORAMA_STYLE, COLORAMA_BG, COLORAMA_FG, formatted_date, Style.RESET_ALL # As a bonus, print the # of tasks in the user's search filter print "\nPS: The total # of tasks with your search filter is: ", COLORAMA_STYLE, \ COLORAMA_BG, COLORAMA_FG, len(list_of_tasks), Style.RESET_ALL, "\n"
def __init__(self, api_key: str, api_secret: str, token: str) -> None: # pylint: disable=import-error from rtmapi import Rtm # type: ignore self.api = Rtm(api_key, api_secret, token=token) self.timeline = self.api.rtm.timelines.create().timeline.value