def get_matching_importer_or_downloader(matching_string: str ) -> List[papis.importer.Importer]: importers = [] # type: List[papis.importer.Importer] logger = logging.getLogger("utils:matcher") _imps = papis.importer.get_importers() _downs = papis.downloaders.get_available_downloaders() _all_importers = list(_imps) + list(_downs) for importer_cls in _all_importers: logger.debug("trying with importer " "{c.Back.BLACK}{c.Fore.YELLOW}{name}{c.Style.RESET_ALL}" .format(c=colorama, name=importer_cls)) importer = importer_cls.match( matching_string) # type: Optional[papis.importer.Importer] if importer: logger.info("{f} {c.Back.BLACK}{c.Fore.GREEN}matches {name}" "{c.Style.RESET_ALL}".format(f=matching_string, c=colorama, name=importer.name)) try: importer.fetch() except Exception as e: logger.error(e) else: importers.append(importer) return importers
def get_matching_importer_or_downloader( matching_string: str) -> List[papis.importer.Importer]: logger = logging.getLogger("utils:matcher") importers = [] # type: List[papis.importer.Importer] _imps = papis.importer.get_importers() _downs = papis.downloaders.get_available_downloaders() _all_importers = list(_imps) + list(_downs) for importer_cls in _all_importers: logger.debug( "trying with importer " "{c.Back.BLACK}{c.Fore.YELLOW}%s{c.Style.RESET_ALL}", importer_cls) try: importer = importer_cls.match( matching_string) # type: Optional[papis.importer.Importer] except Exception as e: logger.error(e) continue if importer: logger.info( "%s {c.Back.BLACK}{c.Fore.GREEN}" "matches %s{c.Style.RESET_ALL}", matching_string, importer.name) try: importer.fetch() except Exception as e: logger.error(e) else: importers.append(importer) return importers
def fetch(self) -> None: _doi = doi.find_doi_in_text(self.uri) if _doi is None: return None importer = Importer(uri=_doi) importer.fetch() self.ctx = importer.ctx
def get_data_from_importer(importer_list, importer_match=[]): """Import the data and files of >>>get_data_from_importer(('bibtex' 'file.bib')) :param importer_list: List of papis importers and files to be added :type set_list: tuple[] :return: Object with imported data and files :rtype: context """ logger = logging.getLogger("import") import_mgr = papis.importer.get_import_mgr() for importer, resource in importer_list: logger.debug("Import with {0} item {1} ".format(importer, resource)) try: importer = import_mgr[importer].plugin(uri=resource) importer.fetch() if importer.ctx: importer_match.append(importer) except Exception as e: logger.exception(e) return importer.ctx
def fetch(self) -> None: docs = papis.pick.pick_doc(papis.api.get_all_documents_in_lib( self.uri)) if not docs: return importer = FromFolderImporter(uri=docs[0].get_main_folder()) importer.fetch() self.ctx = importer.ctx
def match(cls, uri: str) -> Optional[papis.importer.Importer]: """The uri should be a filepath""" filepath = uri if (os.path.isdir(filepath) or not os.path.exists(filepath) or not papis.filetype.get_document_extension(filepath) == 'pdf'): return None importer = DoiFromPdfImporter(filepath) importer.fetch() return importer if importer.doi else None
def fetch(self): self.logger.info("Trying to parse doi from file {0}".format(self.uri)) if not self.doi: self.doi = doi.pdf_to_doi(self.uri, maxlines=2000) if self.doi: self.logger.info("Parsed doi {0}".format(self.doi)) self.logger.warning( "There is no guarantee that this doi is the one") importer = Importer(uri=self.doi) importer.fetch() self.ctx = importer.ctx
def fetch_data(self) -> None: self.logger.info("querying '{0}' to crossref.org".format(self.uri)) docs = [papis.document.from_data(d) for d in get_data(query=self.uri)] if docs: self.logger.info("got {0} matches, picking...".format(len(docs))) docs = list(papis.pick.pick_doc(docs)) if not docs: return doc = docs[0] importer = Importer(uri=doc['doi']) importer.fetch() self.ctx = importer.ctx
def fetch(self) -> None: self.logger.info("Trying to parse DOI from file '%s'", self.uri) if self.ctx: return if not self.doi: self.doi = doi.pdf_to_doi(self.uri, maxlines=2000) if self.doi: self.logger.info("Parsed DOI: '%s'", self.doi) self.logger.warning( "There is no guarantee that this DOI is the correct one") importer = Importer(uri=self.doi) importer.fetch() self.ctx = importer.ctx
def fetch(self): self.logger.info("querying '{0}' to crossref.org".format(self.uri)) docs = [ papis.document.from_data(d) for d in get_data(query=self.uri) ] if docs: self.logger.info("got {0} matches, picking...".format(len(docs))) doc = papis.support.pick.pick_doc(docs) if doc: importer = Importer(uri=doc['doi']) importer.fetch() self.ctx = importer.ctx
def get_matching_importer_or_downloader(matching_string): importers = [] logger = logging.getLogger("utils:matcher") for importer_cls in (papis.importer.get_importers() + papis.downloaders.get_downloaders()): importer = importer_cls.match(matching_string) logger.debug("trying with importer {c.Back.BLACK}{c.Fore.YELLOW}{name}" "{c.Style.RESET_ALL}".format(c=colorama, name=importer_cls)) if importer: logger.info("{f} {c.Back.BLACK}{c.Fore.GREEN}matches {name}" "{c.Style.RESET_ALL}".format(f=matching_string, c=colorama, name=importer.name)) try: importer.fetch() except Exception as e: logger.error(e) else: importers.append(importer) return importers
def match(cls, uri): assert (isinstance(uri, str)) importer = Importer(uri=uri) importer.fetch() return importer if importer.ctx.data else None
def cli(files: List[str], set_list: List[Tuple[str, str]], subfolder: str, folder_name: str, file_name: Optional[str], from_importer: List[Tuple[str, str]], batch: bool, confirm: bool, open_file: bool, edit: bool, git: bool, link: bool, list_importers: bool) -> None: if list_importers: import_mgr = papis.importer.get_import_mgr() for n in import_mgr.names(): print("{name}\n\t{text}".format(name=n, text=re.sub( r"[ \n]+", " ", import_mgr[n].plugin.__doc__))) return from_importer = list(from_importer) logger = logging.getLogger('cli:add') data = dict() for data_set in set_list: data[data_set[0]] = data_set[1] files = list(files) ctx = papis.importer.Context() ctx.files = [f for f in files if os.path.exists(f)] ctx.data.update(data) if batch: edit = False confirm = False open_file = False import_mgr = papis.importer.get_import_mgr() matching_importers = [] # type: List[papis.importer.Importer] if not from_importer and not batch and files: matching_importers = sum( (papis.utils.get_matching_importer_or_downloader(f) for f in files), []) logger.info("These importers where automatically matched, " "select the ones you want to use") _range = papis.tui.utils.select_range([ "{0} (files: {1}) ".format(imp.name, ", ".join(imp.ctx.files)) for imp in matching_importers ], "Select matching importers (for instance 0, 1, 3-10, a, all...)") matching_importers = [matching_importers[i] for i in _range] for importer_tuple in from_importer: try: importer_name = importer_tuple[0] resource = importer_tuple[1] importer = import_mgr[importer_name].plugin(uri=resource) importer.fetch() if importer.ctx: matching_importers.append(importer) except Exception as e: logger.exception(e) if matching_importers: logger.info('There are {0} possible matchings'.format( len(matching_importers))) for importer in matching_importers: if importer.ctx.data: logger.info('Merging data from importer {0}'.format( importer.name)) if batch: ctx.data.update(importer.ctx.data) else: papis.utils.update_doc_from_data_interactively( ctx.data, importer.ctx.data, str(importer)) if importer.ctx.files: logger.info('Got files {0} from importer {1}'.format( importer.ctx.files, importer.name)) for f in importer.ctx.files: papis.utils.open_file(f) _msg = "Use this file? (from {0})".format(importer.name) if batch or papis.tui.utils.confirm(_msg): ctx.files.append(f) if not ctx: logger.error('there is nothing to be added') return if papis.config.getboolean("time-stamp"): ctx.data['time-added'] = time.strftime(papis.strings.time_format) return run(ctx.files, data=ctx.data, folder_name=folder_name, file_name=file_name, subfolder=subfolder, confirm=confirm, open_file=open_file, edit=edit, git=git, link=link)
def match(cls, uri: str) -> Optional[papis.importer.Importer]: importer = Importer(uri=uri) if os.path.exists(uri) and not os.path.isdir(uri): importer.fetch() return importer if importer.ctx.data else None return None
def cli( query: str, git: bool, doc_folder: str, from_importer: List[Tuple[str, str]], auto: bool, _all: bool, sort_field: Optional[str], sort_reverse: bool, set_tuples: List[Tuple[str, str]], ) -> None: """Update a document from a given library.""" logger = logging.getLogger('cli:update') if doc_folder: documents = [papis.document.from_folder(doc_folder)] else: documents = papis.database.get().query(query) if sort_field: documents = papis.document.sort(documents, sort_field, sort_reverse) if not _all: documents = list(papis.pick.pick_doc(documents)) if not documents: logger.error(papis.strings.no_documents_retrieved_message) return for document in documents: ctx = papis.importer.Context() logger.info( 'Updating ' '{c.Back.WHITE}{c.Fore.BLACK}{0}{c.Style.RESET_ALL}'.format( papis.document.describe(document), c=colorama)) ctx.data.update(document) if set_tuples: ctx.data.update({ key: papis.format.format(value, document) for key, value in set_tuples }) matching_importers = [] if not from_importer and auto: for importer_cls in papis.importer.get_importers(): try: importer = importer_cls.match_data(document) if importer: importer.fetch() except NotImplementedError: continue except Exception as e: logger.exception(e) else: if importer and importer.ctx: matching_importers.append(importer) for _importer_name, _uri in from_importer: try: _uri = papis.format.format(_uri, document) _iclass = papis.importer.get_importer_by_name(_importer_name) importer = _iclass(uri=_uri) importer.fetch() if importer.ctx: matching_importers.append(importer) except Exception as e: logger.exception(e) if matching_importers: logger.info('There are {0} possible matchings'.format( len(matching_importers))) for importer in matching_importers: if importer.ctx.data: logger.info('Merging data from importer {0}'.format( importer.name)) papis.utils.update_doc_from_data_interactively( ctx.data, importer.ctx.data, str(importer)) if importer.ctx.files: logger.info('Got files {0} from importer {1}'.format( importer.ctx.files, importer.name)) for f in importer.ctx.files: papis.utils.open_file(f) if papis.tui.utils.confirm("Use this file?"): ctx.files.append(f) run(document, data=ctx.data, git=git)
def cli( query, doc_folder, from_importer, auto, all_entries, set_tuples, ): """Update a document from a given library""" documents = papis.database.get().query(query) logger = logging.getLogger('cli:update') if not documents: logger.warning(log.no_documents_retrieved) if doc_folder: documents = [papis.document.from_folder(doc_folder)] if not all_entries: documents = filter(lambda d: d, [papis.support.pick.pick_doc(documents)]) for document in documents: ctx = papis.importer.Context() logger.info( 'Updating ' '{c.Back.WHITE}{c.Fore.BLACK}{0}{c.Style.RESET_ALL}'.format( papis.document.describe(document), c=colorama)) ctx.data.update(document) if set_tuples: ctx.data.update({ key: papis.utils.format_doc(value, document) for key, value in set_tuples }) matching_importers = [] if not from_importer and auto: for importer_cls in papis.importer.get_importers(): try: importer = importer_cls.match_data(document) importer.fetch() except NotImplementedError: continue except Exception as e: logger.exception(e) else: if importer.ctx: matching_importers.append(importer) for _importer_name, _uri in from_importer: try: _uri = papis.utils.format_doc(_uri, document) importer = ( papis.importer.get_importer_by_name(_importer_name)( uri=_uri)) importer.fetch() if importer.ctx: matching_importers.append(importer) except Exception as e: logger.exception(e) if matching_importers: logger.info('There are {0} possible matchings'.format( len(matching_importers))) for importer in matching_importers: if importer.ctx.data: logger.info('Merging data from importer {0}'.format( importer.name)) papis.tui.applications.update_document_prompt( ctx.data, importer.ctx.data, str(importer)) if importer.ctx.files: logger.info('Got files {0} from importer {1}'.format( importer.ctx.files, importer.name)) for f in importer.ctx.files: papis.utils.open_file(f) if papis.tui.applications.confirm("Use this file?"): ctx.files.append(f) run(document, data=ctx.data)
def fetch(self): doc = papis.support.pick.pick_doc( papis.api.get_all_documents_in_lib(self.uri)) importer = FromFolderImporter(uri=doc.get_main_folder()) importer.fetch() self.ctx = importer.ctx
def fetch(self): importer = Importer(uri=doi.find_doi_in_text(self.uri)) importer.fetch() self.ctx = importer.ctx