How to use jrnl - 10 common examples

def config_var(context, key, value, journal=None):
    t, value = value.split(":")
    value = {"bool": lambda v: v.lower() == "true", "int": int, "str": str}[t](value)
    config = util.load_config(install.CONFIG_FILE_PATH)
    if journal:
        config = config["journals"][journal]
    assert key in config
    assert config[key] == value

path_query = f"Path to your journal file (leave blank for {JOURNAL_FILE_PATH}): "
    journal_path = input(path_query).strip() or JOURNAL_FILE_PATH
    default_config["journals"][DEFAULT_JOURNAL_KEY] = os.path.expanduser(
        os.path.expandvars(journal_path)
    )

    path = os.path.split(default_config["journals"][DEFAULT_JOURNAL_KEY])[
        0
    ]  # If the folder doesn't exist, create it
    try:
        os.makedirs(path)
    except OSError:
        pass

    # Encrypt it?
    encrypt = util.yesno(
        "Do you want to encrypt your journal? You can always change this later",
        default=False,
    )
    if encrypt:
        default_config["encrypt"] = True
        print("Journal will be encrypted.", file=sys.stderr)

    save_config(default_config)
    return default_config

def load_or_install_jrnl():
    """
    If jrnl is already installed, loads and returns a config object.
    Else, perform various prompts to install jrnl.
    """
    config_path = (
        CONFIG_FILE_PATH
        if os.path.exists(CONFIG_FILE_PATH)
        else CONFIG_FILE_PATH_FALLBACK
    )
    if os.path.exists(config_path):
        log.debug("Reading configuration from file %s", config_path)
        config = util.load_config(config_path)

        try:
            upgrade.upgrade_jrnl_if_necessary(config_path)
        except upgrade.UpgradeValidationException:
            print("Aborting upgrade.", file=sys.stderr)
            print(
                "Please tell us about this problem at the following URL:",
                file=sys.stderr,
            )
            print(
                "https://github.com/jrnl-org/jrnl/issues/new?title=UpgradeValidationException",
                file=sys.stderr,
            )
            print("Exiting.", file=sys.stderr)
            sys.exit(1)

raw = util.get_text_from_editor(config, template)
        else:
            try:
                print("[Compose Entry; " + _exit_multiline_code + " to finish writing]\n", file=sys.stderr)
                raw = sys.stdin.read()
            except KeyboardInterrupt:
                print("[Entry NOT saved to journal.]", file=sys.stderr)
                sys.exit(0)
        if raw:
            args.text = [raw]
        else:
            sys.exit()

    # This is where we finally open the journal!
    try:
        journal = open_journal(journal_name, config)
    except KeyboardInterrupt:
        print(f"[Interrupted while opening journal]", file=sys.stderr)
        sys.exit(1)

    # Import mode
    if mode_import:
        plugins.get_importer(args.import_).import_(journal, args.input)

    # Writing mode
    elif mode_compose:
        raw = " ".join(args.text).strip()
        log.debug('Appending raw line "%s" to journal "%s"', raw, journal_name)
        journal.new_entry(raw)
        print(f"[Entry added to {journal_name} journal]", file=sys.stderr)
        journal.write()

# Not encrypting to a separate file: update config!
        if not args.encrypt:
            update_config(original_config, {"encrypt": True}, journal_name, force_local=True)
            install.save_config(original_config)

    elif args.decrypt is not False:
        decrypt(journal, filename=args.decrypt)
        # Not decrypting to a separate file: update config!
        if not args.decrypt:
            update_config(original_config, {"encrypt": False}, journal_name, force_local=True)
            install.save_config(original_config)

    elif args.edit:
        if not config['editor']:
            print("[{1}ERROR{2}: You need to specify an editor in {0} to use the --edit function.]"
                  .format(install.CONFIG_FILE_PATH, ERROR_COLOR, RESET_COLOR), file=sys.stderr)
            sys.exit(1)
        other_entries = [e for e in old_entries if e not in journal.entries]
        # Edit
        old_num_entries = len(journal)
        edited = util.get_text_from_editor(config, journal.editable_str())
        journal.parse_editable_str(edited)
        num_deleted = old_num_entries - len(journal)
        num_edited = len([e for e in journal.entries if e.modified])
        prompts = []
        if num_deleted:
            prompts.append("{} {} deleted".format(num_deleted, "entry" if num_deleted == 1 else "entries"))
        if num_edited:
            prompts.append("{} {} modified".format(num_edited, "entry" if num_deleted == 1 else "entries"))
        if prompts:
            print("[{}]".format(", ".join(prompts).capitalize()), file=sys.stderr)
        journal.entries += other_entries

def run(manual_args=None):
    args = parse_args(manual_args)
    configure_logger(args.debug)
    if args.version:
        version_str = f"{jrnl.__title__} version {jrnl.__version__}"
        print(version_str)
        sys.exit(0)

    try:
        config = install.load_or_install_jrnl()
    except UserAbort as err:
        print(f"\n{err}", file=sys.stderr)
        sys.exit(1)

    if args.ls:
        print(list_journals(config))
        sys.exit(0)

    log.debug('Using configuration "%s"', config)
    original_config = config.copy()

with open(tmpfile) as f:
                    raw = f.read()
                os.remove(tmpfile)
            else:
                print('nothing saved to file')
                raw = ''
        else:
            raw = raw_input("Compose Entry: ")

        if raw:
            args.text = [raw]
        else:
            compose = False

    # open journal
    journal = Journal(config=config)

    # Writing mode
    if compose:
        raw = " ".join(args.text).strip()
        journal.new_entry(raw, args.date)
        print("Entry added.")
        journal.write()

    elif not export: # read mode
        journal.filter(tags=args.text,
                       start_date=args.start_date, end_date=args.end_date,
                       strict=args.strict,
                       short=args.short)
        journal.limit(args.limit)
        print(journal)

with open(filename, 'rb') as f:
            journal_encrypted = f.read()

        def decrypt_journal(password):
            key = make_key(password)
            try:
                plain = Fernet(key).decrypt(journal_encrypted).decode('utf-8')
                self.password = password
                return plain
            except (InvalidToken, IndexError):
                return None

        if self.password:
            return decrypt_journal(self.password)

        return util.decrypt_content(keychain=self.name, decrypt_func=decrypt_journal)

                                lambda match: util.colorize(match.group(0)),
                                pp)

                    lambda match: util.colorize(match.group(0)),
                    pp