fz0x1/jrnl
1
0
Fork 0
mirror of https://github.com/jrnl-org/jrnl.git synced 2025-05-12 09:28:31 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add type hints

Browse source
This commit is contained in:
outa 2022-10-11 16:13:38 +02:00
parent c1eb0c54a3
commit 9e8ec6d31e
17 changed files with 99 additions and 93 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
jrnl/DayOneJournal.py
View file

@ -38,7 +38,7 @@ class DayOne(Journal.Journal):
self.can_be_encrypted = False self.can_be_encrypted = False
super().__init__(**kwargs) super().__init__(**kwargs)
def open(self): def open(self) -> "DayOne":
filenames = [] filenames = []
for root, dirnames, f in os.walk(self.config["journal"]): for root, dirnames, f in os.walk(self.config["journal"]):
for filename in fnmatch.filter(f, "*.doentry"): for filename in fnmatch.filter(f, "*.doentry"):
@ -113,7 +113,7 @@ class DayOne(Journal.Journal):
self.sort() self.sort()
return self return self
def write(self): def write(self) -> None:
"""Writes only the entries that have been modified into plist files.""" """Writes only the entries that have been modified into plist files."""
for entry in self.entries: for entry in self.entries:
if entry.modified: if entry.modified:
@ -177,12 +177,12 @@ class DayOne(Journal.Journal):
) )
os.remove(filename) os.remove(filename)
def editable_str(self): def editable_str(self) -> str:
"""Turns the journal into a string of entries that can be edited """Turns the journal into a string of entries that can be edited
manually and later be parsed with eslf.parse_editable_str.""" manually and later be parsed with eslf.parse_editable_str."""
return "\n".join([f"{str(e)}\n# {e.uuid}\n" for e in self.entries]) return "\n".join([f"{str(e)}\n# {e.uuid}\n" for e in self.entries])
def _update_old_entry(self, entry, new_entry): def _update_old_entry(self, entry: Entry, new_entry: Entry) -> None:
for attr in ("title", "body", "date"): for attr in ("title", "body", "date"):
old_attr = getattr(entry, attr) old_attr = getattr(entry, attr)
new_attr = getattr(new_entry, attr) new_attr = getattr(new_entry, attr)
@ -190,7 +190,7 @@ class DayOne(Journal.Journal):
entry.modified = True entry.modified = True
setattr(entry, attr, new_attr) setattr(entry, attr, new_attr)
def _get_and_remove_uuid_from_entry(self, entry): def _get_and_remove_uuid_from_entry(self, entry: Entry) -> Entry:
uuid_regex = "^ *?# ([a-zA-Z0-9]+) *?$" uuid_regex = "^ *?# ([a-zA-Z0-9]+) *?$"
m = re.search(uuid_regex, entry.body, re.MULTILINE) m = re.search(uuid_regex, entry.body, re.MULTILINE)
entry.uuid = m.group(1) if m else None entry.uuid = m.group(1) if m else None
@ -201,7 +201,7 @@ class DayOne(Journal.Journal):
return entry return entry
def parse_editable_str(self, edited): def parse_editable_str(self, edited: str) -> None:
"""Parses the output of self.editable_str and updates its entries.""" """Parses the output of self.editable_str and updates its entries."""
# Method: create a new list of entries from the edited text, then match # Method: create a new list of entries from the edited text, then match
# UUIDs of the new entries against self.entries, updating the entries # UUIDs of the new entries against self.entries, updating the entries
@ -210,7 +210,7 @@ class DayOne(Journal.Journal):
entries_from_editor = self._parse(edited) entries_from_editor = self._parse(edited)
for entry in entries_from_editor: for entry in entries_from_editor:
entry = self._get_and_remove_uuid_from_entry(entry) self._get_and_remove_uuid_from_entry(entry)
# Remove deleted entries # Remove deleted entries
edited_uuids = [e.uuid for e in entries_from_editor] edited_uuids = [e.uuid for e in entries_from_editor]

15
jrnl/Entry.py
View file

@ -8,12 +8,13 @@ import re
import ansiwrap import ansiwrap
from .Journal import Journal
from .color import colorize from .color import colorize
from .color import highlight_tags_with_background_color from .color import highlight_tags_with_background_color
class Entry: class Entry:
def __init__(self, journal, date=None, text="", starred=False): def __init__(self, journal: Journal, date: datetime.datetime | None = None, text: str = "", starred: bool = False):
self.journal = journal # Reference to journal mainly to access its config self.journal = journal # Reference to journal mainly to access its config
self.date = date or datetime.datetime.now() self.date = date or datetime.datetime.now()
self.text = text self.text = text
@ -24,7 +25,7 @@ class Entry:
self.modified = False self.modified = False
@property @property
def fulltext(self): def fulltext(self) -> str:
return self.title + " " + self.body return self.title + " " + self.body
def _parse_text(self): def _parse_text(self):
@ -68,11 +69,11 @@ class Entry:
self._tags = x self._tags = x
@staticmethod @staticmethod
def tag_regex(tagsymbols): def tag_regex(tagsymbols: str) -> re.Pattern:
pattern = rf"(?<!\S)([{tagsymbols}][-+*#/\w]+)" pattern = rf"(?<!\S)([{tagsymbols}][-+*#/\w]+)"
return re.compile(pattern) return re.compile(pattern)
def _parse_tags(self): def _parse_tags(self) -> set[str]:
tagsymbols = self.journal.config["tagsymbols"] tagsymbols = self.journal.config["tagsymbols"]
return { return {
tag.lower() for tag in re.findall(Entry.tag_regex(tagsymbols), self.text) tag.lower() for tag in re.findall(Entry.tag_regex(tagsymbols), self.text)
@ -90,7 +91,7 @@ class Entry:
body=self.body.rstrip("\n "), body=self.body.rstrip("\n "),
) )
def pprint(self, short=False): def pprint(self, short: bool = False) -> str:
"""Returns a pretty-printed version of the entry. """Returns a pretty-printed version of the entry.
If short is true, only print the title.""" If short is true, only print the title."""
# Handle indentation # Handle indentation
@ -197,7 +198,7 @@ class Entry:
def __hash__(self): def __hash__(self):
return hash(self.__repr__()) return hash(self.__repr__())
def __eq__(self, other): def __eq__(self, other: "Entry"):
if ( if (
not isinstance(other, Entry) not isinstance(other, Entry)
or self.title.strip() != other.title.strip() or self.title.strip() != other.title.strip()
@ -230,7 +231,7 @@ SENTENCE_SPLITTER = re.compile(
SENTENCE_SPLITTER_ONLY_NEWLINE = re.compile("\n") SENTENCE_SPLITTER_ONLY_NEWLINE = re.compile("\n")
def split_title(text): def split_title(text: str) -> tuple[str, str]:
"""Splits the first sentence off from a text.""" """Splits the first sentence off from a text."""
sep = SENTENCE_SPLITTER_ONLY_NEWLINE.search(text.lstrip()) sep = SENTENCE_SPLITTER_ONLY_NEWLINE.search(text.lstrip())
if not sep: if not sep:

15
jrnl/FolderJournal.py
View file

@ -7,9 +7,10 @@ import os
from jrnl import Journal from jrnl import Journal
from jrnl import time from jrnl import time
from jrnl.Entry import Entry
def get_files(journal_config): def get_files(journal_config: str) -> list[str]:
"""Searches through sub directories starting with journal_config and find all text files""" """Searches through sub directories starting with journal_config and find all text files"""
filenames = [] filenames = []
for root, dirnames, f in os.walk(journal_config): for root, dirnames, f in os.walk(journal_config):
@ -21,13 +22,13 @@ def get_files(journal_config):
class Folder(Journal.Journal): class Folder(Journal.Journal):
"""A Journal handling multiple files in a folder""" """A Journal handling multiple files in a folder"""
def __init__(self, name="default", **kwargs): def __init__(self, name: str = "default", **kwargs):
self.entries = [] self.entries = []
self._diff_entry_dates = [] self._diff_entry_dates = []
self.can_be_encrypted = False self.can_be_encrypted = False
super().__init__(name, **kwargs) super().__init__(name, **kwargs)
def open(self): def open(self) -> "Folder":
filenames = [] filenames = []
self.entries = [] self.entries = []
filenames = get_files(self.config["journal"]) filenames = get_files(self.config["journal"])
@ -38,7 +39,7 @@ class Folder(Journal.Journal):
self.sort() self.sort()
return self return self
def write(self): def write(self) -> None:
"""Writes only the entries that have been modified into proper files.""" """Writes only the entries that have been modified into proper files."""
# Create a list of dates of modified entries. Start with diff_entry_dates # Create a list of dates of modified entries. Start with diff_entry_dates
modified_dates = self._diff_entry_dates modified_dates = self._diff_entry_dates
@ -81,13 +82,13 @@ class Folder(Journal.Journal):
if os.stat(filename).st_size <= 0: if os.stat(filename).st_size <= 0:
os.remove(filename) os.remove(filename)
def delete_entries(self, entries_to_delete): def delete_entries(self, entries_to_delete: list[Entry]) -> None:
"""Deletes specific entries from a journal.""" """Deletes specific entries from a journal."""
for entry in entries_to_delete: for entry in entries_to_delete:
self.entries.remove(entry) self.entries.remove(entry)
self._diff_entry_dates.append(entry.date) self._diff_entry_dates.append(entry.date)
def change_date_entries(self, date): def change_date_entries(self, date: str) -> None:
"""Changes entry dates to given date.""" """Changes entry dates to given date."""
date = time.parse(date) date = time.parse(date)
@ -98,7 +99,7 @@ class Folder(Journal.Journal):
self._diff_entry_dates.append(entry.date) self._diff_entry_dates.append(entry.date)
entry.date = date entry.date = date
def parse_editable_str(self, edited): def parse_editable_str(self, edited: str) -> None:
"""Parses the output of self.editable_str and updates its entries.""" """Parses the output of self.editable_str and updates its entries."""
mod_entries = self._parse(edited) mod_entries = self._parse(edited)
diff_entries = set(self.entries) - set(mod_entries) diff_entries = set(self.entries) - set(mod_entries)

4
jrnl/args.py
View file

@ -20,7 +20,7 @@ from jrnl.plugins import util
class WrappingFormatter(argparse.RawTextHelpFormatter): class WrappingFormatter(argparse.RawTextHelpFormatter):
"""Used in help screen""" """Used in help screen"""
def _split_lines(self, text, width): def _split_lines(self, text: str, width: int) -> list[str]:
text = text.split("\n\n") text = text.split("\n\n")
text = map(lambda t: self._whitespace_matcher.sub(" ", t).strip(), text) text = map(lambda t: self._whitespace_matcher.sub(" ", t).strip(), text)
text = map(lambda t: textwrap.wrap(t, width=56), text) text = map(lambda t: textwrap.wrap(t, width=56), text)
@ -28,7 +28,7 @@ class WrappingFormatter(argparse.RawTextHelpFormatter):
return text return text
def parse_args(args=[]): def parse_args(args: list[str] = []) -> argparse.Namespace:
""" """
Argument parsing that is doable before the config is available. Argument parsing that is doable before the config is available.
Everything else goes into "text" for later parsing. Everything else goes into "text" for later parsing.

4
jrnl/cli.py
View file

@ -16,7 +16,7 @@ from jrnl.messages import MsgText
from jrnl.output import print_msg from jrnl.output import print_msg
def configure_logger(debug=False): def configure_logger(debug: bool = False) -> None:
if not debug: if not debug:
logging.disable() logging.disable()
return return
@ -31,7 +31,7 @@ def configure_logger(debug=False):
logging.getLogger("keyring.backend").setLevel(logging.ERROR) logging.getLogger("keyring.backend").setLevel(logging.ERROR)
def cli(manual_args=None): def cli(manual_args: list[str] | None = None) -> int:
try: try:
if manual_args is None: if manual_args is None:
manual_args = sys.argv[1:] manual_args = sys.argv[1:]

11
jrnl/color.py
View file

@ -7,13 +7,14 @@ from string import whitespace
import colorama import colorama
from jrnl.Entry import Entry
from jrnl.os_compat import on_windows from jrnl.os_compat import on_windows
if on_windows(): if on_windows():
colorama.init() colorama.init()
def colorize(string, color, bold=False): def colorize(string: str, color: str, bold: bool = False) -> str:
"""Returns the string colored with colorama.Fore.color. If the color set by """Returns the string colored with colorama.Fore.color. If the color set by
the user is "NONE" or the color doesn't exist in the colorama.Fore attributes, the user is "NONE" or the color doesn't exist in the colorama.Fore attributes,
it returns the string without any modification.""" it returns the string without any modification."""
@ -26,7 +27,9 @@ def colorize(string, color, bold=False):
return colorama.Style.BRIGHT + color_escape + string + colorama.Style.RESET_ALL return colorama.Style.BRIGHT + color_escape + string + colorama.Style.RESET_ALL
def highlight_tags_with_background_color(entry, text, color, is_title=False): def highlight_tags_with_background_color(
entry: Entry, text: str, color: str, is_title: bool = False
) -> str:
""" """
Takes a string and colorizes the tags in it based upon the config value for Takes a string and colorizes the tags in it based upon the config value for
color.tags, while colorizing the rest of the text based on `color`. color.tags, while colorizing the rest of the text based on `color`.
@ -45,9 +48,9 @@ def highlight_tags_with_background_color(entry, text, color, is_title=False):
:returns [(colorized_str, original_str)]""" :returns [(colorized_str, original_str)]"""
for part in fragments: for part in fragments:
if part and part[0] not in config["tagsymbols"]: if part and part[0] not in config["tagsymbols"]:
yield (colorize(part, color, bold=is_title), part) yield colorize(part, color, bold=is_title), part
elif part: elif part:
yield (colorize(part, config["colors"]["tags"], bold=True), part) yield colorize(part, config["colors"]["tags"], bold=True), part
config = entry.journal.config config = entry.journal.config
if config["highlight"]: # highlight tags if config["highlight"]: # highlight tags

21
jrnl/config.py
View file

@ -4,6 +4,7 @@
import argparse import argparse
import logging import logging
import os import os
from typing import Any
from typing import Callable from typing import Callable
import colorama import colorama
@ -57,7 +58,7 @@ def make_yaml_valid_dict(input: list) -> dict:
return runtime_modifications return runtime_modifications
def save_config(config, alt_config_path=None): def save_config(config: dict, alt_config_path: str | None = None) -> None:
"""Supply alt_config_path if using an alternate config through --config-file.""" """Supply alt_config_path if using an alternate config through --config-file."""
config["version"] = __version__ config["version"] = __version__
@ -72,7 +73,7 @@ def save_config(config, alt_config_path=None):
yaml.dump(config, f) yaml.dump(config, f)
def get_config_path(): def get_config_path() -> str:
try: try:
config_directory_path = xdg.BaseDirectory.save_config_path(XDG_RESOURCE) config_directory_path = xdg.BaseDirectory.save_config_path(XDG_RESOURCE)
except FileExistsError: except FileExistsError:
@ -91,7 +92,7 @@ def get_config_path():
return os.path.join(config_directory_path or home_dir(), DEFAULT_CONFIG_NAME) return os.path.join(config_directory_path or home_dir(), DEFAULT_CONFIG_NAME)
def get_default_config(): def get_default_config() -> dict[str, Any]:
return { return {
"version": __version__, "version": __version__,
"journals": {"default": {"journal": get_default_journal_path()}}, "journals": {"default": {"journal": get_default_journal_path()}},
@ -114,12 +115,12 @@ def get_default_config():
} }
def get_default_journal_path(): def get_default_journal_path() -> str:
journal_data_path = xdg.BaseDirectory.save_data_path(XDG_RESOURCE) or home_dir() journal_data_path = xdg.BaseDirectory.save_data_path(XDG_RESOURCE) or home_dir()
return os.path.join(journal_data_path, DEFAULT_JOURNAL_NAME) return os.path.join(journal_data_path, DEFAULT_JOURNAL_NAME)
def scope_config(config, journal_name): def scope_config(config: dict, journal_name: str) -> dict:
if journal_name not in config["journals"]: if journal_name not in config["journals"]:
return config return config
config = config.copy() config = config.copy()
@ -139,7 +140,7 @@ def scope_config(config, journal_name):
return config return config
def verify_config_colors(config): def verify_config_colors(config: dict) -> bool:
""" """
Ensures the keys set for colors are valid colorama.Fore attributes, or "None" Ensures the keys set for colors are valid colorama.Fore attributes, or "None"
:return: True if all keys are set correctly, False otherwise :return: True if all keys are set correctly, False otherwise
@ -164,7 +165,7 @@ def verify_config_colors(config):
return all_valid_colors return all_valid_colors
def load_config(config_path): def load_config(config_path: str) -> dict:
"""Tries to load a config file from YAML.""" """Tries to load a config file from YAML."""
try: try:
with open(config_path, encoding=YAML_FILE_ENCODING) as f: with open(config_path, encoding=YAML_FILE_ENCODING) as f:
@ -187,13 +188,13 @@ def load_config(config_path):
return yaml.load(f) return yaml.load(f)
def is_config_json(config_path): def is_config_json(config_path: str) -> bool:
with open(config_path, "r", encoding="utf-8") as f: with open(config_path, "r", encoding="utf-8") as f:
config_file = f.read() config_file = f.read()
return config_file.strip().startswith("{") return config_file.strip().startswith("{")
def update_config(config, new_config, scope, force_local=False): def update_config(config: dict, new_config: dict, scope: str | None, force_local: bool = False) -> None:
"""Updates a config dict with new values - either global if scope is None """Updates a config dict with new values - either global if scope is None
or config['journals'][scope] is just a string pointing to a journal file, or config['journals'][scope] is just a string pointing to a journal file,
or within the scope""" or within the scope"""
@ -206,7 +207,7 @@ def update_config(config, new_config, scope, force_local=False):
config.update(new_config) config.update(new_config)
def get_journal_name(args, config): def get_journal_name(args: argparse.Namespace, config: dict) -> argparse.Namespace:
args.journal_name = DEFAULT_JOURNAL_KEY args.journal_name = DEFAULT_JOURNAL_KEY
# The first arg might be a journal name # The first arg might be a journal name

4
jrnl/editor.py
View file

@ -17,7 +17,7 @@ from jrnl.os_compat import split_args
from jrnl.output import print_msg from jrnl.output import print_msg
def get_text_from_editor(config, template=""): def get_text_from_editor(config: dict, template: str = "") -> str:
suffix = ".jrnl" suffix = ".jrnl"
if config["template"]: if config["template"]:
template_filename = Path(config["template"]).name template_filename = Path(config["template"]).name
@ -50,7 +50,7 @@ def get_text_from_editor(config, template=""):
return raw return raw
def get_text_from_stdin(): def get_text_from_stdin() -> str:
print_msg( print_msg(
Message( Message(
MsgText.WritingEntryStart, MsgText.WritingEntryStart,

14
jrnl/install.py
View file

@ -27,7 +27,7 @@ from jrnl.prompt import yesno
from jrnl.upgrade import is_old_version from jrnl.upgrade import is_old_version
def upgrade_config(config_data, alt_config_path=None): def upgrade_config(config_data: dict, alt_config_path: str | None = None) -> None:
"""Checks if there are keys missing in a given config dict, and if so, updates the config file accordingly. """Checks if there are keys missing in a given config dict, and if so, updates the config file accordingly.
This essentially automatically ports jrnl installations if new config parameters are introduced in later This essentially automatically ports jrnl installations if new config parameters are introduced in later
versions. versions.
@ -46,7 +46,7 @@ def upgrade_config(config_data, alt_config_path=None):
) )
def find_default_config(): def find_default_config() -> str:
config_path = ( config_path = (
get_config_path() get_config_path()
if os.path.exists(get_config_path()) if os.path.exists(get_config_path())
@ -55,7 +55,7 @@ def find_default_config():
return config_path return config_path
def find_alt_config(alt_config): def find_alt_config(alt_config: str) -> str:
if not os.path.exists(alt_config): if not os.path.exists(alt_config):
raise JrnlException( raise JrnlException(
Message( Message(
@ -66,7 +66,7 @@ def find_alt_config(alt_config):
return alt_config return alt_config
def load_or_install_jrnl(alt_config_path): def load_or_install_jrnl(alt_config_path: str) -> dict:
""" """
If jrnl is already installed, loads and returns a default config object. If jrnl is already installed, loads and returns a default config object.
If alternate config is specified via --config-file flag, it will be used. If alternate config is specified via --config-file flag, it will be used.
@ -107,7 +107,7 @@ def load_or_install_jrnl(alt_config_path):
return config return config
def install(): def install() -> dict:
_initialize_autocomplete() _initialize_autocomplete()
# Where to create the journal? # Where to create the journal?
@ -143,7 +143,7 @@ def install():
return default_config return default_config
def _initialize_autocomplete(): def _initialize_autocomplete() -> None:
# readline is not included in Windows Active Python and perhaps some other distributions # readline is not included in Windows Active Python and perhaps some other distributions
if sys.modules.get("readline"): if sys.modules.get("readline"):
import readline import readline
@ -153,7 +153,7 @@ def _initialize_autocomplete():
readline.set_completer(_autocomplete_path) readline.set_completer(_autocomplete_path)
def _autocomplete_path(text, state): def _autocomplete_path(text: str, state: int) -> list[str | None]:
expansions = glob.glob(expand_path(text) + "*") expansions = glob.glob(expand_path(text) + "*")
expansions = [e + "/" if os.path.isdir(e) else e for e in expansions] expansions = [e + "/" if os.path.isdir(e) else e for e in expansions]
expansions.append(None) expansions.append(None)

38
jrnl/jrnl.py
View file

@ -1,6 +1,6 @@
# Copyright © 2012-2022 jrnl contributors # Copyright © 2012-2022 jrnl contributors
# License: https://www.gnu.org/licenses/gpl-3.0.html # License: https://www.gnu.org/licenses/gpl-3.0.html
from argparse import Namespace
import logging import logging
import sys import sys
@ -13,8 +13,10 @@ from jrnl.config import get_journal_name
from jrnl.config import scope_config from jrnl.config import scope_config
from jrnl.editor import get_text_from_editor from jrnl.editor import get_text_from_editor
from jrnl.editor import get_text_from_stdin from jrnl.editor import get_text_from_stdin
from jrnl.Entry import Entry
from jrnl.exception import JrnlException from jrnl.exception import JrnlException
from jrnl.Journal import open_journal from jrnl.Journal import open_journal
from jrnl.Journal import Journal
from jrnl.messages import Message from jrnl.messages import Message
from jrnl.messages import MsgStyle from jrnl.messages import MsgStyle
from jrnl.messages import MsgText from jrnl.messages import MsgText
@ -24,7 +26,7 @@ from jrnl.override import apply_overrides
from jrnl.path import expand_path from jrnl.path import expand_path
def run(args): def run(args: Namespace):
""" """
Flow: Flow:
1. Run standalone command if it doesn't require config (help, version, etc), then exit 1. Run standalone command if it doesn't require config (help, version, etc), then exit
@ -72,10 +74,8 @@ def run(args):
search_mode(**kwargs) search_mode(**kwargs)
def _is_write_mode(args, config, **kwargs): def _is_write_mode(args: Namespace, config: dict, **kwargs) -> bool:
"""Determines if we are in write mode (as opposed to search mode)""" """Determines if we are in write mode (as opposed to search mode)"""
write_mode = True
# Are any search filters present? If so, then search mode. # Are any search filters present? If so, then search mode.
write_mode = not any( write_mode = not any(
( (
@ -115,7 +115,7 @@ def _is_write_mode(args, config, **kwargs):
return write_mode return write_mode
def write_mode(args, config, journal, **kwargs): def write_mode(args: Namespace, config: dict, journal: Journal, **kwargs) -> None:
""" """
Gets input from the user to write to the journal Gets input from the user to write to the journal
1. Check for input from cli 1. Check for input from cli
@ -159,7 +159,7 @@ def write_mode(args, config, journal, **kwargs):
logging.debug("Write mode: completed journal.write()") logging.debug("Write mode: completed journal.write()")
def search_mode(args, journal, **kwargs): def search_mode(args: Namespace, journal: Journal, **kwargs) -> None:
""" """
Search for entries in a journal, then either: Search for entries in a journal, then either:
1. Send them to configured editor for user manipulation (and also 1. Send them to configured editor for user manipulation (and also
@ -213,7 +213,7 @@ def search_mode(args, journal, **kwargs):
_display_search_results(**kwargs) _display_search_results(**kwargs)
def _write_in_editor(config, template=None): def _write_in_editor(config: dict, template: str | None = None) -> str:
if config["editor"]: if config["editor"]:
logging.debug("Write mode: opening editor") logging.debug("Write mode: opening editor")
if not template: if not template:
@ -226,7 +226,7 @@ def _write_in_editor(config, template=None):
return raw return raw
def _get_editor_template(config, **kwargs): def _get_editor_template(config: dict, **kwargs) -> str:
logging.debug("Write mode: loading template for entry") logging.debug("Write mode: loading template for entry")
if not config["template"]: if not config["template"]:
@ -251,7 +251,7 @@ def _get_editor_template(config, **kwargs):
return template return template
def _has_search_args(args): def _has_search_args(args: Namespace) -> bool:
return any( return any(
( (
args.on_date, args.on_date,
@ -271,7 +271,7 @@ def _has_search_args(args):
) )
def _filter_journal_entries(args, journal, **kwargs): def _filter_journal_entries(args: Namespace, journal: Journal, **kwargs) -> None:
"""Filter journal entries in-place based upon search args""" """Filter journal entries in-place based upon search args"""
if args.on_date: if args.on_date:
args.start_date = args.end_date = args.on_date args.start_date = args.end_date = args.on_date
@ -296,7 +296,7 @@ def _filter_journal_entries(args, journal, **kwargs):
journal.limit(args.limit) journal.limit(args.limit)
def _print_entries_found_count(count, args): def _print_entries_found_count(count: int, args: Namespace) -> None:
if count == 0: if count == 0:
if args.edit or args.change_time: if args.edit or args.change_time:
print_msg(Message(MsgText.NothingToModify, MsgStyle.WARNING)) print_msg(Message(MsgText.NothingToModify, MsgStyle.WARNING))
@ -317,12 +317,12 @@ def _print_entries_found_count(count, args):
print_msg(Message(my_msg, MsgStyle.NORMAL, {"num": count})) print_msg(Message(my_msg, MsgStyle.NORMAL, {"num": count}))
def _other_entries(journal, entries): def _other_entries(journal: Journal, entries: list[Entry]) -> list[Entry]:
"""Find entries that are not in journal""" """Find entries that are not in journal"""
return [e for e in entries if e not in journal.entries] return [e for e in entries if e not in journal.entries]
def _edit_search_results(config, journal, old_entries, **kwargs): def _edit_search_results(config: dict, journal: Journal, old_entries: list[Entry], **kwargs) -> None:
""" """
1. Send the given journal entries to the user-configured editor 1. Send the given journal entries to the user-configured editor
2. Print out stats on any modifications to journal 2. Print out stats on any modifications to journal
@ -356,7 +356,7 @@ def _edit_search_results(config, journal, old_entries, **kwargs):
journal.write() journal.write()
def _print_edited_summary(journal, old_stats, **kwargs): def _print_edited_summary(journal: Journal, old_stats: dict[str, int], **kwargs) -> None:
stats = { stats = {
"added": len(journal) - old_stats["count"], "added": len(journal) - old_stats["count"],
"deleted": old_stats["count"] - len(journal), "deleted": old_stats["count"] - len(journal),
@ -395,11 +395,11 @@ def _print_edited_summary(journal, old_stats, **kwargs):
print_msgs(msgs) print_msgs(msgs)
def _get_predit_stats(journal): def _get_predit_stats(journal: Journal) -> dict[str, int]:
return {"count": len(journal)} return {"count": len(journal)}
def _delete_search_results(journal, old_entries, **kwargs): def _delete_search_results(journal: Journal, old_entries: list[Entry], **kwargs) -> None:
entries_to_delete = journal.prompt_action_entries(MsgText.DeleteEntryQuestion) entries_to_delete = journal.prompt_action_entries(MsgText.DeleteEntryQuestion)
if entries_to_delete: if entries_to_delete:
@ -409,7 +409,7 @@ def _delete_search_results(journal, old_entries, **kwargs):
journal.write() journal.write()
def _change_time_search_results(args, journal, old_entries, no_prompt=False, **kwargs): def _change_time_search_results(args: Namespace, journal: Journal, old_entries: list[Entry], no_prompt: bool = False, **kwargs) -> None:
# separate entries we are not editing # separate entries we are not editing
other_entries = _other_entries(journal, old_entries) other_entries = _other_entries(journal, old_entries)
@ -432,7 +432,7 @@ def _change_time_search_results(args, journal, old_entries, no_prompt=False, **k
journal.write() journal.write()
def _display_search_results(args, journal, **kwargs): def _display_search_results(args: Namespace, journal: Journal, **kwargs) -> None:
# Get export format from config file if not provided at the command line # Get export format from config file if not provided at the command line
args.export = args.export or kwargs["config"].get("display_format") args.export = args.export or kwargs["config"].get("display_format")

6
jrnl/os_compat.py
View file

@ -5,14 +5,14 @@ import shlex
from sys import platform from sys import platform
def on_windows(): def on_windows() -> bool:
return "win32" in platform return "win32" in platform
def on_posix(): def on_posix() -> bool:
return not on_windows() return not on_windows()
def split_args(args): def split_args(args: str) -> list[str]:
"""Split arguments and add escape characters as appropriate for the OS""" """Split arguments and add escape characters as appropriate for the OS"""
return shlex.split(args, posix=on_posix()) return shlex.split(args, posix=on_posix())

18
jrnl/output.py
View file

@ -2,7 +2,7 @@
# License: https://www.gnu.org/licenses/gpl-3.0.html # License: https://www.gnu.org/licenses/gpl-3.0.html
import textwrap import textwrap
from typing import Union from typing import Callable
from rich.console import Console from rich.console import Console
from rich.text import Text from rich.text import Text
@ -12,7 +12,7 @@ from jrnl.messages import MsgStyle
from jrnl.messages import MsgText from jrnl.messages import MsgText
def deprecated_cmd(old_cmd, new_cmd, callback=None, **kwargs): def deprecated_cmd(old_cmd: str, new_cmd: str, callback: Callable | None = None, **kwargs) -> None:
print_msg( print_msg(
Message( Message(
MsgText.DeprecatedCommand, MsgText.DeprecatedCommand,
@ -25,13 +25,13 @@ def deprecated_cmd(old_cmd, new_cmd, callback=None, **kwargs):
callback(**kwargs) callback(**kwargs)
def journal_list_to_json(journal_list): def journal_list_to_json(journal_list: dict) -> str:
import json import json
return json.dumps(journal_list) return json.dumps(journal_list)
def journal_list_to_yaml(journal_list): def journal_list_to_yaml(journal_list: dict) -> str:
from io import StringIO from io import StringIO
from ruamel.yaml import YAML from ruamel.yaml import YAML
@ -41,7 +41,7 @@ def journal_list_to_yaml(journal_list):
return output.getvalue() return output.getvalue()
def journal_list_to_stdout(journal_list): def journal_list_to_stdout(journal_list: dict) -> str:
result = f"Journals defined in config ({journal_list['config_path']})\n" result = f"Journals defined in config ({journal_list['config_path']})\n"
ml = min(max(len(k) for k in journal_list["journals"]), 20) ml = min(max(len(k) for k in journal_list["journals"]), 20)
for journal, cfg in journal_list["journals"].items(): for journal, cfg in journal_list["journals"].items():
@ -51,7 +51,7 @@ def journal_list_to_stdout(journal_list):
return result return result
def list_journals(configuration, format=None): def list_journals(configuration: dict, format: str | None = None) -> str:
from jrnl import config from jrnl import config
"""List the journals specified in the configuration file""" """List the journals specified in the configuration file"""
@ -69,7 +69,7 @@ def list_journals(configuration, format=None):
return journal_list_to_stdout(journal_list) return journal_list_to_stdout(journal_list)
def print_msg(msg: Message, **kwargs) -> Union[None, str]: def print_msg(msg: Message, **kwargs) -> str | None:
"""Helper function to print a single message""" """Helper function to print a single message"""
kwargs["style"] = msg.style kwargs["style"] = msg.style
return print_msgs([msg], **kwargs) return print_msgs([msg], **kwargs)
@ -81,7 +81,7 @@ def print_msgs(
style: MsgStyle = MsgStyle.NORMAL, style: MsgStyle = MsgStyle.NORMAL,
get_input: bool = False, get_input: bool = False,
hide_input: bool = False, hide_input: bool = False,
) -> Union[None, str]: ) -> str | None:
# Same as print_msg, but for a list # Same as print_msg, but for a list
text = Text("", end="") text = Text("", end="")
kwargs = style.decoration.args kwargs = style.decoration.args
@ -113,7 +113,7 @@ def _get_console(stderr: bool = True) -> Console:
return Console(stderr=stderr) return Console(stderr=stderr)
def _add_extra_style_args_if_needed(args, msg): def _add_extra_style_args_if_needed(args: dict, msg: Message):
args["border_style"] = msg.style.color args["border_style"] = msg.style.color
args["title"] = msg.style.box_title args["title"] = msg.style.box_title
return args return args

4
jrnl/override.py
View file

@ -37,12 +37,12 @@ def apply_overrides(args: "Namespace", base_config: dict) -> dict:
return base_config return base_config
def _get_key_and_value_from_pair(pairs): def _get_key_and_value_from_pair(pairs: dict) -> tuple:
key_as_dots, override_value = list(pairs.items())[0] key_as_dots, override_value = list(pairs.items())[0]
return key_as_dots, override_value return key_as_dots, override_value
def _convert_dots_to_list(key_as_dots): def _convert_dots_to_list(key_as_dots: str) -> list[str]:
keys = key_as_dots.split(".") keys = key_as_dots.split(".")
keys = [k for k in keys if k != ""] # remove empty elements keys = [k for k in keys if k != ""] # remove empty elements
return keys return keys

6
jrnl/path.py
View file

@ -4,13 +4,13 @@
import os.path import os.path
def home_dir(): def home_dir() -> str:
return os.path.expanduser("~") return os.path.expanduser("~")
def expand_path(path): def expand_path(path: str) -> str:
return os.path.expanduser(os.path.expandvars(path)) return os.path.expanduser(os.path.expandvars(path))
def absolute_path(path): def absolute_path(path: str) -> str:
return os.path.abspath(expand_path(path)) return os.path.abspath(expand_path(path))

2
jrnl/prompt.py
View file

@ -42,7 +42,7 @@ def create_password(journal_name: str) -> str:
return pw return pw
def yesno(prompt: Message, default: bool = True) -> bool: def yesno(prompt: Message | str, default: bool = True) -> bool:
response = print_msgs( response = print_msgs(
[ [
prompt, prompt,

6
jrnl/time.py
View file

@ -8,7 +8,7 @@ DEFAULT_FUTURE = datetime.datetime(FAKE_YEAR, 12, 31, 23, 59, 59)
DEFAULT_PAST = datetime.datetime(FAKE_YEAR, 1, 1, 0, 0) DEFAULT_PAST = datetime.datetime(FAKE_YEAR, 1, 1, 0, 0)
def __get_pdt_calendar(): def __get_pdt_calendar() -> "pdt.Calendar":
try: try:
import parsedatetime.parsedatetime_consts as pdt import parsedatetime.parsedatetime_consts as pdt
except ImportError: except ImportError:
@ -22,8 +22,8 @@ def __get_pdt_calendar():
def parse( def parse(
date_str, inclusive=False, default_hour=None, default_minute=None, bracketed=False date_str: str | datetime.datetime, inclusive: bool = False, default_hour: int | None = None, default_minute: int | None = None, bracketed: bool = False
): ) -> datetime.datetime | None:
"""Parses a string containing a fuzzy date and returns a datetime.datetime object""" """Parses a string containing a fuzzy date and returns a datetime.datetime object"""
if not date_str: if not date_str:
return None return None

10
jrnl/upgrade.py
View file

@ -19,7 +19,7 @@ from jrnl.path import expand_path
from jrnl.prompt import yesno from jrnl.prompt import yesno
def backup(filename, binary=False): def backup(filename: str, binary: bool = False):
filename = expand_path(filename) filename = expand_path(filename)
try: try:
@ -42,14 +42,14 @@ def backup(filename, binary=False):
raise JrnlException(Message(MsgText.UpgradeAborted, MsgStyle.WARNING)) raise JrnlException(Message(MsgText.UpgradeAborted, MsgStyle.WARNING))
def check_exists(path): def check_exists(path: str) -> bool:
""" """
Checks if a given path exists. Checks if a given path exists.
""" """
return os.path.exists(path) return os.path.exists(path)
def upgrade_jrnl(config_path): def upgrade_jrnl(config_path: str) -> None:
config = load_config(config_path) config = load_config(config_path)
print_msg(Message(MsgText.WelcomeToJrnl, MsgStyle.NORMAL, {"version": __version__})) print_msg(Message(MsgText.WelcomeToJrnl, MsgStyle.NORMAL, {"version": __version__}))
@ -115,7 +115,7 @@ def upgrade_jrnl(config_path):
cont = yesno(Message(MsgText.ContinueUpgrade), default=False) cont = yesno(Message(MsgText.ContinueUpgrade), default=False)
if not cont: if not cont:
raise JrnlException(Message(MsgText.UpgradeAborted), MsgStyle.WARNING) raise JrnlException(Message(MsgText.UpgradeAborted, MsgStyle.WARNING))
for journal_name, path in encrypted_journals.items(): for journal_name, path in encrypted_journals.items():
print_msg( print_msg(
@ -178,7 +178,7 @@ def upgrade_jrnl(config_path):
print_msg(Message(MsgText.AllDoneUpgrade, MsgStyle.NORMAL)) print_msg(Message(MsgText.AllDoneUpgrade, MsgStyle.NORMAL))
def is_old_version(config_path): def is_old_version(config_path: str) -> bool:
return is_config_json(config_path) return is_config_json(config_path)