def _find_db(
search_path,
maxdepth=6,
filename="collection.anki2",
break_on_first=False,
user: Optional[str] = None,
) -> DefaultDict[str, List[Path]]:
"""
Like find_database but only for one search path at a time. Also doesn't
raise any error, even if the search path doesn't exist.
Args:
search_path:
maxdepth: Maximum depth relative to search_path
filename:
break_on_first: Break on first search result
user: Only search for this user
Returns:
collection.defaultdict({user: [list of results]})
"""
search_path = Path(search_path)
if not search_path.exists():
log.debug("_find_db: Search path %r does not exist.", str(search_path))
return collections.defaultdict(list)
if search_path.is_file():
if search_path.name == filename:
return collections.defaultdict(
list, {search_path.parent.name: [search_path]}
)
else:
log.warning(
"_find_db: Search path %r is a file, but filename does not "
"match that of %r.",
str(search_path),
filename,
)
return collections.defaultdict(list)
found = collections.defaultdict(list) # type: DefaultDict[str, List[Path]]
for root, dirs, files in os.walk(str(search_path)):
if filename in files:
_user = os.path.basename(root)
if user and not _user == user:
continue
found[_user].append(Path(root) / filename)
if break_on_first:
log.debug("_find_db: Breaking after first hit.")
break
depth = len(Path(root).relative_to(search_path).parts)
if maxdepth and depth >= maxdepth:
# log.debug(
# "_find_db: Abort search at %r. "
# "Max depth exceeded.",
# str(root)
# )
del dirs[:]
return found
def _consolidate_tables(
df: pd.DataFrame, df_old: pd.DataFrame, mode: str, id_column="id"
):
if not list(df.columns) == list(df_old.columns):
raise ValueError(
"Columns do not match: Old: {}, New: {}".format(
", ".join(df_old.columns), ", ".join(df.columns)
)
)
old_indices = set(df_old[id_column])
new_indices = set(df[id_column])
# Get indices
# -----------
if mode == "update":
indices = set(old_indices)
elif mode == "append":
indices = set(new_indices) - set(old_indices)
if not indices:
log.warning(
"Was told to append to table, but there do not seem to be any"
" new entries. "
)
elif mode == "replace":
indices = set(new_indices)
else:
raise ValueError(f"Unknown mode '{mode}'.")
df = df[df[id_column].isin(indices)]
# Apply
# -----
if mode == "update":
df_new = df_old.copy()
df_new.update(df)
elif mode == "append":
df_new = df_old.append(df, verify_integrity=True)
elif mode == "replace":
df_new = df.copy()
else:
raise ValueError(f"Unknown mode '{mode}'.")
return df_new
def _find_db(
search_path,
maxdepth=6,
filename="collection.anki2",
break_on_first=False,
user=None,
):
"""
Like find_database but only for one search path at a time. Also doesn't
raise any error, even if the search path doesn't exist.
Returns:
collection.defaultdict({user: [list of results]})
"""
search_path = pathlib.Path(search_path)
if not search_path.exists():
log.debug("_find_db: Search path '{}' does not "
"exist.".format(str(search_path)))
return collections.defaultdict(list)
if search_path.is_file():
if search_path.name == filename:
return collections.defaultdict(
list, {search_path.parent.name: [search_path]})
else:
log.warning(
"_find_db: Search path '{}' is a file, but filename does not "
"match that of '{}'.".format(str(search_path), filename))
return collections.defaultdict(list)
found = collections.defaultdict(list)
for root, dirs, files in os.walk(str(search_path)):
if filename in files:
_user = os.path.basename(root)
if user and not _user == user:
continue
found[_user].append(pathlib.Path(root) / filename)
if break_on_first:
log.debug("_find_db: Breaking after first hit.")
break
if maxdepth and root.count(os.sep) >= maxdepth:
log.debug("_find_db: Abort search at '{}'. "
"Max depth exceeded.".format(str(root)))
del dirs[:]
return found
def find_db(
search_paths=None,
maxdepth=8,
filename="collection.anki2",
user=None,
break_on_first=True,
) -> pathlib.Path:
"""
Find path to anki2 database.
Args:
search_paths: Search path as string or pathlib object or list/iterable
thereof. If None, some search paths are set by default.
maxdepth: Maximal search depth.
filename: Filename of the collection (default: ``collections.anki2``)
user: Username to which the collection belongs. If None, search for
databases of any user.
break_on_first: Stop searching once a database is found. This is
obviously faster, but you will not get any errors if there are
multiple databases matching your criteria.
Raises:
If none ore more than one result is found: :class:`ValueError`
Returns:
pathlib.Path to the anki2 database
"""
if not search_paths:
log.info("Searching for database. This might take some time. "
"You can speed this up by specifying a search path or "
"directly entering the path to your database.")
search_paths = [
"~/.local/share/Anki2/",
"~/Documents/Anki2",
pathlib.Path(os.getenv("APPDATA", "~") + "/Anki2/"),
"~/.local/share/Anki2",
pathlib.Path.home(),
]
search_paths = [
pathlib.Path(sp).expanduser().resolve() for sp in search_paths
]
if break_on_first:
log.warning(
"The search will stop at the first hit, so please verify that "
"the result is correct (for example in case there might be more "
"than one Anki installation)")
if isinstance(search_paths, (str, pathlib.PurePath)):
search_paths = [search_paths]
found = {}
for search_path in search_paths:
found = {
**found,
**_find_db(
search_path,
maxdepth=maxdepth,
filename=filename,
user=user,
break_on_first=break_on_first,
),
}
if break_on_first:
if user is not None:
if user in found:
break
else:
if found:
break
if user:
if user not in found:
raise ValueError(
f"Could not find database belonging to user {user}")
found = found[user]
else:
if len(found) >= 2:
raise ValueError(
"Found databases for more than one user: {}. Please specify "
"the user.".format(", ".join(found)))
elif not found:
raise ValueError(
"No database found. You might increase the search depth or "
"specify search paths to find more.")
else:
found = found.popitem()[1]
if len(found) >= 2:
raise ValueError(
"Found more than one database belonging to user {} at {}".format(
user, ", ".join(map(str, found))))
found = found[0]
log.debug("Database found at %r.", found)
return found
def write(
self,
modify=False,
add=False,
delete=False,
backup_folder: Union[PurePath, str] = None,
):
""" Creates a backup of the database and then writes back the new
data.
.. danger::
The switches ``modify``, ``add`` and ``delete`` will run additional
cross-checks, but do not rely on them to 100%!
.. warning::
It is recommended to run :meth:`summarize_changes` before to check
whether the changes match your expectation.
.. note::
Please make sure to thoroughly check your collection in Anki after
every write process!
Args:
modify: Allow modification of existing items (notes, cards, etc.)
add: Allow adding of new items (notes, cards, etc.)
delete: Allow deletion of items (notes, cards, etc.)
backup_folder: Path to backup folder. If None is given, the backup
is created in the Anki backup directory (if found).
Returns:
None
"""
if not modify and not add and not delete:
log.warning(
"Please set modify=True, add=True or delete=True, you're"
" literally not allowing me any modification at all."
)
return None
try:
prepared = self._prepare_write_data(
modify=modify, add=add, delete=delete
)
info = self._get_and_update_info()
except Exception as e:
log.critical(
"Something went wrong preparing the data for writing. "
"However, no data has been written out, so your"
"database is save!"
)
raise e
else:
log.debug("Successfully prepared data for writing.")
backup_path = ankipandas.paths.backup_db(
self.path, backup_folder=backup_folder
)
log.info("Backup created at {}.".format(backup_path.resolve()))
# Actually setting values here, after all conversion tasks have been
# carried out. That way if any of them fails, we don't have a
# partially written collection.
log.debug("Now actually writing to database.")
try:
for table, values in prepared.items():
raw.set_table(
self.db, values["raw"], table=table, mode=values["mode"]
)
# Actually only needed if we actually modify the info.
# This will trigger a complete re-upload, so we want to avoid this
# if possible.
# raw.set_info(self.db, info)
except Exception as e:
log.critical(
"Error while writing data to database at {path}"
"This means that your database might have become corrupted. "
"It's STRONGLY adviced that you manually restore the database "
"by replacing it with the backup from {backup_path} and restart"
" from scratch. "
"Please also open a bug report at "
"https://github.com/klieret/AnkiPandas/issues/, as errors "
"during the actual writing process should never occurr!".format(
path=self.path.resolve(), backup_path=backup_path.resolve()
)
)
raise e
def test_log(self):
log.info("Test info")
log.warning("Test warning")
def write(
self,
modify=False,
add=False,
delete=False,
backup_folder: Union[PurePath, str] = None,
):
""" Creates a backup of the database and then writes back the new
data.
.. danger::
The switches ``modify``, ``add`` and ``delete`` will run additional
cross-checks, but do not rely on them to 100%!
.. warning::
It is recommended to run :meth:`summarize_changes` before to check
whether the changes match your expectation.
.. note::
Please make sure to thoroughly check your collection in Anki after
every write process!
Args:
modify: Allow modification of existing items (notes, cards, etc.)
add: Allow adding of new items (notes, cards, etc.)
delete: Allow deletion of items (notes, cards, etc.)
backup_folder: Path to backup folder. If None is given, the backup
is created in the Anki backup directory (if found).
Returns:
None
"""
if not modify and not add and not delete:
log.warning(
"Please set modify=True, add=True or delete=True, you're"
" literally not allowing me any modification at all.")
return None
try:
prepared = self._prepare_write_data(modify=modify,
add=add,
delete=delete)
log.debug("Now getting & updating info.")
info = self._get_and_update_info()
except Exception as e:
log.critical(
"Something went wrong preparing the data for writing. "
"However, no data has been written out, so your "
"database is save!")
raise e
else:
log.debug("Successfully prepared data for writing.")
if prepared == {}:
log.warning(
"Nothing seems to have been changed. Will not do anything!")
return None
backup_path = ankipandas.paths.backup_db(self.path,
backup_folder=backup_folder)
log.info(f"Backup created at {backup_path.resolve()}.")
log.warning(
"Currently AnkiPandas might not be able to tell Anki to"
" sync its database. "
"You might have to manually tell Anki to sync everything "
"to AnkiDroid.\n"
"Furthermore, if you run into issues with tag searches not working"
"anymore, please first do Notes > Clear unused notes and then "
"Tools > Check Database (from the main menu). This should get them"
" to work (sorry about this issue).")
# Actually setting values here, after all conversion tasks have been
# carried out. That way if any of them fails, we don't have a
# partially written collection.
log.debug("Now actually writing to database.")
try:
for table, values in prepared.items():
log.debug(f"Now setting table {table}.")
raw.set_table(self.db,
values["raw"],
table=table,
mode=values["mode"])
log.debug(f"Setting table {table} successful.")
# log.debug("Now setting info")
# raw.set_info(self.db, info)
# log.debug("Setting info successful.")
except Exception as e:
log.critical(
"Error while writing data to database at {path}"
"This means that your database might have become corrupted. "
"It's STRONGLY advised that you manually restore the database "
"by replacing it with the backup from {backup_path} and restart"
" from scratch. "
"Please also open a bug report at "
"https://github.com/klieret/AnkiPandas/issues/, as errors "
"during the actual writing process should never occur!".format(
path=self.path.resolve(),
backup_path=backup_path.resolve()))
raise e