"""Create an asset in DataTrails with User Token.

The module contains two functions: main and create_asset. Main function parses in
a url to the Archivist and credentials, which is a user authorization.
The main function would initialize an archivist connection using the url and
the credentials, called "arch", then call arch.assets.create() and the asset will be created.
"""

from os import getenv

from archivist.archivist import Archivist


def create_asset(arch):
    """Create an asset using Archivist Connection.

    Args:
        arch: archivist connection.

    Returns:
        newasset: a new asset created.

    """
    attrs = {
        "arc_display_name": "display_name",  # Asset's display name in the user interface
        "arc_description": "display_description",  # Asset's description in the user interface
        "arc_display_type": "display_type",  # Arc_display_type is a free text field
        # allowing the creator of
        # an asset to specify the asset
        # type or class. Be careful when setting this:
        # assets are grouped by type and
        # sharing policies can be
        # configured to share assets based on
        # their arc_display_type.
        # So a mistake here can result in asset data being
        # under- or over-shared.
        "some_custom_attribute": "value"  # You can add any custom value as long as
        # it does not start with arc_
    }
    #
    # There are 3 alternatives
    #
    # 1. Create the asset:
    #    The first argument is the attributes of the asset
    return arch.assets.create(attrs=attrs)
    #
    # 2. alternatively one can wait for the asset to be confirmed in the
    #    immutable store.
    #    The second argument is wait for confirmation:
    #      If @confirm@ is True then this function will not
    #      return until the asset is confirmed.
    #
    # Confirmation guarantees that 3rd parties can retrieve and cryptographically
    # verify your Assets, which can take a few seconds to propagate. It is typically
    # not necessary to wait unless your workflow involves near-real-time
    # communication with 3rd parties and the 3rd party needs immediate cryptographic
    # verification of your new Asset.
    return arch.assets.create(attrs=attrs, confirm=True)
    #
    # 3. lastly if some work can be done whilst the asset is confirmed then this call
    # can be replaced by a two-step alternative:

    asset = arch.assets.create(props=props, attrs=attrs)

    # ... do something else here
    # and then wait for confirmation

    return arch.assets.wait_for_confirmation(asset['identity']))


def main():
    """Main function of create asset.

    Parse in user input of url and client id/secrets and use them to
    create an example archivist connection and create an asset.

    """

    # client id and client secret is obtained from the appidp endpoint - see the
    # application registrations example code in examples/applications_registration.py
    #
    # client id is an environment variable. client_secret is stored in a file in a
    # directory that has 0700 permissions. The location of this file is set in
    # the client_secret_filename environment variable.
    client_id = getenv("DATATRAILS_APPREG_CLIENT")
    client_secret_file = getenv("DATATRAILS_APPREG_SECRET_FILENAME")
    with open(client_secret_file, mode="r", encoding="utf-8") as tokenfile:
        client_secret = tokenfile.read().strip()

    # Initialize connection to Archivist. max_time is the time to wait for confirmation
    # of an asset or event creation - the default is 300 seconds but one can optionally
    # specify a different value.
    with arch = Archivist(
        "https://app.datatrails.ai",
        (client_id, client_secret),
        max_time=300,
    ) as arch:
        # Create a new asset
        asset = create_asset(arch)
        print("Asset", asset)


if __name__ == "__main__":
    main()

from logging import getLogger
from pyaml_env import parse_config
from sys import exit as sys_exit
from sys import stdout as sys_stdout

from archivist import about
from archivist.archivist import Archivist
from archivist.parser import common_parser, endpoint

LOGGER = getLogger(__name__)

def run(arch: Archivist, args):

    LOGGER.info("Using version %s of datatrails-archivist", about.__version__)
    LOGGER.info("Namespace %s", args.namespace)

    with open(args.yamlfile, "r", encoding="utf-8") as y:
        arch.runner(parse_config(data=y)

    sys_exit(0)

def main():
    parser = common_parser("Executes the archivist runner from a yaml file")

    parser.add_argument(
        "yamlfile", help="the yaml file describing the steps to conduct"
    )
    args = parser.parse_args()

    arch = endpoint(args)

    run(arch, args)

    parser.print_help(sys_stdout)
    sys_exit(1)

import logging

logging.dictConfig({
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
        },
    },
    "root": {
        "handlers": ["console"],
        "level": "INFO",
    },
})

from archivist.logger import set_logger
from archivist.archivist import Archivist

set_logger("DEBUG")
client_id = getenv("DATATRAILS_APPREG_CLIENT")
client_secret_file = getenv("DATATRAILS_APPREG_SECRET_FILENAME")
with open(client_secret_file, mode="r", encoding="utf-8") as tokenfile:
    client_secret = tokenfile.read().strip()

arch = Archivist(
    "https://app.datatrails.ai",
    (client_id, client_secret),
    max_time=300,
)