def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
num: int = args.id
question: Optional[str] = args.question
answers: Optional[List[str]] = args.answer
tags: Optional[List[str]] = args.tag
new_num: Optional[int] = args.new_id
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
card = db.get_card_by_num(session, deck, num)
if not util.confirm(
'Are you sure you want to update card #%d (%r)?' %
(card.num, card.question)):
return
if question is not None:
card.question = question
if answers is not None:
card.answers = answers
if tags is not None:
card.tags = [
db.get_tag_by_name(session, deck, tag) for tag in tags
]
if new_num is not None:
db.move_card(session, card, new_num)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
how_many: Optional[int] = args.n
mode: Mode = args.mode
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
_review(session, deck, how_many, mode)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
deck_description: Optional[str] = args.description
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
if deck_description is not None:
deck.description = deck_description
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
if not util.confirm(
'Are you sure you want to delete deck %r?' % deck_name):
return
session.delete(deck)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
tag_name: str = args.tag
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
tag = db.get_tag_by_name(session, deck, tag_name)
if not util.confirm(
'Are you sure you want to delete tag %r?' % tag.name):
return
session.delete(tag)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
deck_description: str = args.description
with db.session_scope() as session:
if db.try_get_deck_by_name(session, deck_name):
raise error.DeckAlreadyExistsError(
'A deck with name %r already exists' % deck_name)
deck = db.Deck()
deck.name = deck_name
deck.description = deck_description
session.add(deck)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
path: str = args.output
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
if path:
with open(path, 'w') as handle:
_write_report(deck, session, handle)
else:
_write_report(deck, session, sys.stdout)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
tag_name: str = args.name
tag_color: Optional[str] = args.color
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
tag = db.Tag()
tag.name = tag_name
tag.color = tag_color
deck.tags.append(tag)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
num: int = args.id
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
card = db.get_card_by_num(session, deck, num)
if not util.confirm(
"Are you sure you want to delete card #%d (%r)?" %
(card.num, card.question)):
return
for user_answer in card.user_answers:
session.delete(user_answer)
session.delete(card)
def run(self, _args: argparse.Namespace) -> None:
with db.session_scope() as session:
if not session.query(db.Deck).count():
print("No decks to show.")
return
results = session.query(db.Deck.id, db.Deck.name,
db.Deck.description)
for deck_id, name, description in results:
card_count = (session.query(sa.func.count(
db.Deck.cards)).filter(db.Deck.id == deck_id).scalar())
print("%s: %s (%d cards)" %
(name, description or "(no description)", card_count))
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
tags = (session.query(
db.Tag).filter(db.Tag.deck_id == deck.id).all())
if not tags:
print("No tags to show.")
return
for i, tag in enumerate(tags):
_print_single_tag(session, i, tag)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
tag_name: str = args.tag
tag_color: Optional[str] = args.color
new_tag_name: Optional[str] = args.name
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
tag = db.get_tag_by_name(session, deck, tag_name)
if tag_color is not None:
tag.color = tag_color
if new_tag_name is not None:
tag.name = new_tag_name
def _import(handle: IO[Any]) -> None:
with db.session_scope() as session:
deck_obj = json.load(handle)
deck = db.Deck()
deck.name = deck_obj['name']
deck.description = deck_obj['description']
existing_deck = db.try_get_deck_by_name(session, deck.name)
if existing_deck:
if not util.confirm(
'Are you sure you want to overwrite deck %r?' % deck.name):
return
session.delete(existing_deck)
session.commit()
tag_dict = {}
for tag_obj in deck_obj['tags']:
tag = db.Tag()
tag.name = tag_obj['name']
tag.color = tag_obj['color']
deck.tags.append(tag)
tag_dict[tag.name] = tag
for card_obj in deck_obj['cards']:
card = db.Card()
card.num = card_obj['id']
card.question = card_obj['question']
card.answers = card_obj['answers']
card.is_active = card_obj['active']
card.tags = [tag_dict[name] for name in card_obj['tags']]
for user_answer_obj in card_obj['user_answers']:
user_answer = db.UserAnswer()
user_answer.date = parse_date(user_answer_obj['date'])
user_answer.is_correct = user_answer_obj['correct']
card.user_answers.append(user_answer)
if 'activation_date' in card_obj:
if card_obj['activation_date']:
card.activation_date = parse_date(
card_obj['activation_date'])
elif card.user_answers:
card.activation_date = sorted(card.user_answers,
key=lambda ua: ua.date)[0].date
card.due_date = scheduler.next_due_date(card)
deck.cards.append(card)
session.add(deck)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
how_many: int = args.n
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
cards_to_study = scheduler.get_cards_to_study(
session, deck, how_many)
if not cards_to_study:
print('No cards to study.')
return
print('%d cards to study. After seeing a card, hit enter.' %
len(cards_to_study))
print()
for index, card in enumerate(cards_to_study):
_learn_single_card(index, cards_to_study, card)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
path: Optional[str] = args.path
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
deck = (session.query(
db.Deck).filter(db.Deck.id == deck.id).options(
sa.orm.subqueryload(db.Deck.cards).subqueryload(
db.Card.tags),
sa.orm.subqueryload(db.Deck.cards).subqueryload(
db.Card.user_answers),
).one())
if path:
with open(path, "w") as handle:
_export(deck, handle)
else:
_export(deck, sys.stdout)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
question: Optional[str] = args.question
tag: Optional[str] = args.tag
sort_style: str = args.sort
show_answers: bool = args.show_answers
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
cards = session \
.query(db.Card) \
.filter(db.Card.deck_id == deck.id) \
.options(sa.orm.subqueryload('user_answers'))
if question is not None:
cards = cards.filter(
sa.func.lower(db.Card.question).like(
sa.func.lower(question)))
if sort_style == SORT_NONE:
cards = cards.order_by(db.Card.num.asc())
elif sort_style == SORT_DUE_DATE:
cards = cards.order_by(db.Card.is_active.desc())
cards = cards.order_by(db.Card.due_date.asc())
cards = cards.order_by(db.Card.num.asc())
else:
assert False
cards = cards.all()
if tag is not None:
cards = [
card
for card in cards
if tag.lower() in [t.name.lower() for t in card.tags]]
if not cards:
print('No cards to show.')
return
index_length = ceil(log10(db.get_max_card_num(session, deck)))
for card in cards:
_print_single_card(index_length, card, show_answers)
def run(self, args: argparse.Namespace) -> None:
deck_name: str = args.deck
question: str = args.question
answers: List[str] = args.answer
tags: List[str] = args.tag or []
prepend: bool = args.place == PREPEND
with db.session_scope() as session:
deck = db.get_deck_by_name(session, deck_name)
max_card_num = db.get_max_card_num(session, deck)
card = db.Card()
card.num = max_card_num + 1
card.question = question
card.answers = answers
card.tags = [
db.get_tag_by_name(session, deck, tag) for tag in tags
]
card.is_active = False
card.due_date = None
deck.cards.append(card)
if prepend:
max_active_card_num = db.get_max_active_card_num(session, deck)
db.move_card(session, card, max_active_card_num + 1)
