def run(self):
        r = stringutil.u(self.args.regex)
        s = stringutil.u(self.args.sub)
        if self.args.recursive:
            for dirpath, dirs, filenames in os.walk(self.args.dir):
                for fname in filenames:
                    self.process_file(r, s, dirpath, fname)
        else:
            filenames = os.listdir(self.args.dir)
            for fname in filenames:
                self.process_file(r, s, self.args.dir, fname)

        n = len(self.filenames_map)
        sn = len(str(n))

        for i, (k, v) in enumerate(self.filenames_map.iteritems()):
            print(u"%*d. %s => %s" % (sn, i + 1, k, v))

        if consoleutil.confirm("Do you want to do the rename?"):
            for i, (k, v) in enumerate(self.filenames_map.iteritems()):
                print("%*d. Rename %s to %s" % (sn, i + 1, k, v))
                os.rename(k, v)
            return 0
        else:
            print("Aborted")
            return 1
    def entries(self, do_cleanup=False):
        """Prints out all the entries for all the feeds"""
        _log.debug("Get all the category ids first")
        categories = self.get_categories()

        duplicated_entries = []
        seen_fingerprints = set()
        total_num_entries = 0

        endpoint = self._get_endpoint("/streams/contents")
        for category in categories:
            headers = self._get_headers()
            params = {
                'streamId': category['id'],
                'count': 1000,  # max is 1000
                'unreadOnly': "true"
            }
            resp = requests.get(endpoint, headers=headers, params=params)
            _log.debug("Response: %s", resp.__dict__)

            content = json.loads(resp.text)
            #from sorno import debuggingutil
            #debuggingutil.ipython_here()

            title = None
            if 'title' in content:
                title = content['title']
            else:
                title = content['id']
                if '/' in title:
                    title = title.split('/')[-1]

            print("Title:", title)
            updated = datetimeutil.timestamp_to_local_datetime(
                content['updated'] / 1000
            )
            print("Updated:", updated.strftime("%Y/%m/%d %H:%M"))
            print("Id:", content['id'])
            if 'items' in content:
                num_entries = len(content['items'])
                total_num_entries += num_entries
                for i, entry in enumerate(content['items']):
                    print(" " * 4 + "(%d/%d)" % (i + 1, num_entries))
                    self._print_entry(entry, indent=" " * 4)
                    print("")

                    if entry['fingerprint'] in seen_fingerprints:
                        duplicated_entries.append(entry)
                    else:
                        seen_fingerprints.add(entry['fingerprint'])

        print("\nTotal of %d entries\n" % total_num_entries)

        print("Duplicated entries:")
        num_entries = len(duplicated_entries)
        for i, duplicated_entry in enumerate(duplicated_entries):
            print(" " * 4 + "(%d/%d)" % (i + 1, num_entries))
            self._print_entry(duplicated_entry, indent=" " * 4)
            print("")

        if num_entries == 0:
            print("None")
        elif do_cleanup:
            ans = consoleutil.confirm(
                "Mark %d duplicated entries as read?" % num_entries)
            if ans:
                resp = self.mark_entries_as_read(
                    [entry['id'] for entry in duplicated_entries]
                )

                if resp.status_code == 200:
                    print("Done")
                else:
                    print(resp.status_code, resp.reason)
    def delete_tasks_action(self, args):
        self.auth(args, use_credentials_cache=args.use_credentials_cache)

        # ask the user to choose a task list that contains the tasks

        tasklists = self.get_tasklists()
        for index, tasklist in enumerate(tasklists, 1):
            print(
                "{0}) {1} (id: {2})".format(
                    index,
                    tasklist['title'],
                    tasklist['id'],
                )
            )

        ans = consoleutil.input(
            "Please choose the list that contains the tasks: "
        )

        intvs = consoleutil.parse_intervals(ans)
        list_number = intvs[0].start
        chosen_tasklist = tasklists[list_number - 1]

        _plain_logger.info("")
        # ask the user to choose the tasks from the chosen task list

        tasks = self.get_tasks_from_tasklist(chosen_tasklist['id'])

        _plain_logger.info(
            "Tasklist [%s] has the following tasks:",
            chosen_tasklist['title'],
        )
        self._print_tasks_with_ids(tasks)

        ans = consoleutil.input(
            "Please choose the tasks that you want to delete: "
        )

        intvs = consoleutil.parse_intervals(ans)

        chosen_tasks = []
        for intv in intvs:
            chosen_tasks.extend(
                # the start and end in interals are one-based, so need to
                # reduce them each by 1
                tasks[intv.start - 1:intv.end]
            )

        dups = self._get_duplicated_items(chosen_tasks)
        if dups:
            _plain_logger.error(
                "The following tasks are chosen more than once:"
            )
            self._print_tasks_with_ids(dups, ref=tasks)
            return GoogleTasksConsoleApp.EXIT_CODE_USER_INPUT_ERROR

        _plain_logger.info("Chosen tasks:")
        self._print_tasks_with_ids(chosen_tasks, ref=tasks)

        _plain_logger.info("")

        # ask the user to confirm
        confirm_msg = re.sub(
            r"\s+",
            " ",
            """
            Are you sure you want to delete the chosen tasks from task list?
            [{0}]
            """.strip().format(
                chosen_tasklist['title'],
            ),
        )

        if not consoleutil.confirm(confirm_msg):
            _plain_error_logger.error("Aborted")
            return GoogleTasksConsoleApp.EXIT_CODE_USER_ABORT

        # delete the tasks

        for task in chosen_tasks:
            self.delete_task(chosen_tasklist['id'], task['id'])

        return 0