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
