Пример #1
0
    def do_all(self):
        log = self.api.logger
        tempfilename = os.path.splitext(os.path.basename(sys.argv[0]))[0]
        cache = os.path.join(gettempdir(), tempfilename + "." + self.mid + ".p")
        members = []
        if os.path.exists(cache) and not self.clean:
            log.info("Reusing from " + cache)
            members = pickle.load(open(cache, "rb"))
        else:
            if not self.clean:
                log.info("Not found " + cache)

            MU.descendants(self.api, self.mid, batch=200, target=members, segments=self.segments, episodes=self.episodes,
                           log_progress=True)
            pickle.dump(members, open(cache, "wb"))

        log.info("Found " + str(len(members)) + " objects")
        count = 0

        for idx, member in enumerate(MU.iterate_objects(members)):
            member_mid = member.mid
            # noinspection PyUnusedLocal
            main_title = MU.title(member, "MAIN")
            # noinspection PyUnusedLocal
            short_title = MU.title(member, "SHORT")
            member_type = MU.mediatype(member)
            string = "%s %s (%s)" % (member_type, member_mid, main_title)

            if self.filter:
                try :
                    result = self.filter(member, idx)
                    log.debug("%s Execed %s result %s", str(idx), self.filter_description, str(result))
                    if not result:
                        log.info("%s Skipping %s because of filter %s", str(idx), string, self.filter_description)
                        continue
                except Exception as e:
                    log.warning("%s %s", str(member.mid), str(e))
                    continue

            needs_post = self.process(member, idx)
            if needs_post is None:
                needs_post = True
            log.debug(" needs post %s", str(needs_post))
            if needs_post:
                if not self.dryrun:
                    log.info("%s Execed %s for %s and posting", str(idx), self.processor_description, string)
                    self.do_one(member, idx)
                else:
                    log.info("%s Execed %s for %s (not posting because of dryrun parameter)", str(idx),
                         self.processor_description, string)
            else:
                log.info("%s Skipping %s for %s", str(idx), self.processor_description, string)

            count += 1

        if self.include_self:
            if not self.dryrun:
                log.info("%s %s", self.description, self.mid)
                object = self.api.get_object(self.mid)
                log.info("Found %s", str(object))
                self.do_one(object, None)
            else:
                log.info("Dry run %s %s", self.description, self.mid)
            count += 1

        log.info("Ready. %s %s object from POMS", self.description, str(count))
        return count
Пример #2
0
else:
    if not clean:
        log.info("Not found " + cache)
    MU.descendants(api, mid, batch=200, target=members, segments=False, episodes=False, log_progress=True)
    pickle.dump(members, open(cache, "wb"))

log.info("Found " + str(len(members)) + " objects")
posts = 0

if os.path.exists(process):
    log.info("%s is a file.", str(process))
    process = open(process).read()

for idx, member in enumerate(MU.iterate_objects(members)):
    member_mid = member.mid
    main_title = MU.title(member, "MAIN")
    short_title = MU.title(member, "SHORT")
    if filter:
        result = eval(filter)
        log.debug("%s Execed %s result %s", str(idx), str(filter), str(result))
        if not result:
            log.debug("Skipping %s, %s %s because of filter %s", str(type(member)), str(member.type), member_mid,
                            filter)
            continue

    exec(process)

    if not args.dryrun:
        log.info("%s Execed %s for %s and posting", str(idx), process, member_mid)
        api.post(member)
    else: