def __init__(self, _db, mirror, user_id, password, uploader=None, soap_client=None): self._db = _db self.mirror = mirror if self.mirror: self.scaler = ImageScaler(_db, [self.mirror], uploader=uploader) else: self.scaler = None self.user_id = user_id self.password = password self.soap_client = (soap_client or ContentCafeSOAPClient(user_id, password))
def __init__(self, collection, uploader=None, viaf_client=None, linked_data_coverage_provider=None, content_cafe_api=None, overdrive_api_class=OverdriveAPI, **kwargs): super(IdentifierResolutionCoverageProvider, self).__init__(collection, **kwargs) # Since we are the metadata wrangler, any resources we find, # we mirror to S3. if not uploader: uploader = S3Uploader.from_config(self._db) self.uploader = uploader # We're going to be aggressive about recalculating the presentation # for this work because either the work is currently not set up # at all, or something went wrong trying to set it up. self.policy = PresentationCalculationPolicy( regenerate_opds_entries=True) self.overdrive_api = self.create_overdrive_api(overdrive_api_class) self.content_cafe_api = content_cafe_api # Determine the optional and required coverage providers. # Each Identifier in this Collection's catalog will be run # through all relevant providers. self.required_coverage_providers, self.optional_coverage_providers = self.providers( ) # When we need to look up a contributor via VIAF we will use this # client. self.viaf_client = viaf_client or VIAFClient(self._db) # Books are not looked up in OCLC Linked Data directly, since # there is no Collection that identifies a book by its OCLC Number. # However, when a book is looked up through OCLC Classify, some # OCLC Numbers may be associated with it, and _those_ numbers # can be run through OCLC Linked Data. # # TODO: We get many books identified by ISBN, and those books # _could_ be run through a LinkedDataCoverageProvider if it # worked a little differently. However, I don't think this # would be very useful, since those books will get looked up # through OCLC Classify, which will probably result in us # finding that same ISBN via OCLC Number. self.oclc_linked_data = (linked_data_coverage_provider or LinkedDataCoverageProvider( self._db, viaf_api=self.viaf_client)) # The ordinary OverdriveBibliographicCoverageProvider # doesn't upload images, so we need to create our own # mirror and scaler. # # TODO: This class would be neater if we were to subclass # OverdriveBibliographicCoverageProvider to do the scaling and # uploading. self.image_mirrors = { DataSource.OVERDRIVE: OverdriveCoverImageMirror(self._db, uploader=uploader) } self.image_scaler = ImageScaler(self._db, self.image_mirrors.values(), uploader=uploader)
def run(self): mirrors = [OverdriveCoverImageMirror] ImageScaler(self._db, mirrors).run(force=self.force)