dsw-tdk 4.20.1__py2.py3-none-any.whl → 4.22.0__py2.py3-none-any.whl

dsw/tdk/api_client.py

@@ -9,7 +9,7 @@ from .consts import DEFAULT_ENCODING, APP, VERSION
 from .model import Template, TemplateFile, TemplateFileType
 
 
-class DSWCommunicationError(RuntimeError):
+class WizardCommunicationError(RuntimeError):
 
     def __init__(self, reason: str, message: str):
         """
@@ -28,31 +28,31 @@ def handle_client_errors(func):
     async def handled_client_call(job, *args, **kwargs):
         try:
             return await func(job, *args, **kwargs)
-        except DSWCommunicationError as e:
+        except WizardCommunicationError as e:
             # Already DSWCommunicationError (re-raise)
             raise e
         except aiohttp.client_exceptions.ContentTypeError as e:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Unexpected response type',
                 message=e.message
             ) from e
         except aiohttp.client_exceptions.ClientResponseError as e:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Error response status',
                 message=f'Server responded with error HTTP status {e.status}: {e.message}'
             ) from e
         except aiohttp.client_exceptions.InvalidURL as e:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Invalid URL',
                 message=f'Provided API URL seems invalid: {e.url}'
             ) from e
         except aiohttp.client_exceptions.ClientConnectorError as e:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Server unreachable',
                 message=f'Desired server is not reachable (errno {e.os_error.errno})'
             ) from e
         except Exception as e:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Communication error',
                 message=f'Communication with server failed ({e})'
             ) from e
@@ -60,7 +60,7 @@ def handle_client_errors(func):
 
 
 # pylint: disable-next=too-many-public-methods
-class DSWAPIClient:
+class WizardAPIClient:
 
     def _headers(self, extra=None):
         headers = {
@@ -75,7 +75,7 @@ class DSWAPIClient:
     def _check_status(r: aiohttp.ClientResponse, expected_status):
         r.raise_for_status()
         if r.status != expected_status:
-            raise DSWCommunicationError(
+            raise WizardCommunicationError(
                 reason='Unexpected response status',
                 message=f'Server responded with unexpected HTTP status {r.status}: '
                         f'{r.reason} (expecting {expected_status})'
@@ -158,7 +158,13 @@ class DSWAPIClient:
     async def login(self, email: str, password: str) -> str | None:
         req = {'email': email, 'password': password}
         body = await self._post_json('/tokens', json=req)
-        self.token = body.get('token', None)
+        token_value = body.get('token', None)
+        if not isinstance(token_value, str):
+            raise WizardCommunicationError(
+                reason='Invalid response',
+                message='Server did not return a valid token'
+            )
+        self.token = token_value
         return self.token
 
     @handle_client_errors
@@ -220,8 +226,8 @@ class DSWAPIClient:
         result = []
         for file_body in body:
             file_id = file_body['uuid']
-            template_file = await self.get_template_draft_file(remote_id, file_id)
-            result.append(template_file)
+            file = await self.get_template_draft_file(remote_id, file_id)
+            result.append(file)
         return result
 
     @handle_client_errors
@@ -270,23 +276,23 @@ class DSWAPIClient:
         return _load_remote_template(body)
 
     @handle_client_errors
-    async def post_template_draft_file(self, remote_id: str, tfile: TemplateFile):
+    async def post_template_draft_file(self, remote_id: str, file: TemplateFile):
         data = await self._post_json(
             endpoint=f'/document-template-drafts/{remote_id}/files',
             json={
-                'fileName': tfile.filename.as_posix(),
-                'content': tfile.content.decode(DEFAULT_ENCODING)
+                'fileName': file.filename.as_posix(),
+                'content': file.content.decode(DEFAULT_ENCODING)
             }
         )
         return _load_remote_file(data)
 
     @handle_client_errors
-    async def put_template_draft_file_content(self, remote_id: str, tfile: TemplateFile):
+    async def put_template_draft_file_content(self, remote_id: str, file: TemplateFile):
         self.session.headers.update(self._headers())
         async with self.session.put(
                 f'{self.api_url}/document-template-drafts/{remote_id}'
-                f'/files/{tfile.remote_id}/content',
-                data=tfile.content,
+                f'/files/{file.remote_id}/content',
+                data=file.content,
                 headers={'Content-Type': 'text/plain;charset=UTF-8'},
         ) as r:
             self._check_status(r, expected_status=200)
@@ -294,17 +300,17 @@ class DSWAPIClient:
             return _load_remote_file(body)
 
     @handle_client_errors
-    async def post_template_draft_asset(self, remote_id: str, tfile: TemplateFile):
+    async def post_template_draft_asset(self, remote_id: str, file: TemplateFile):
         data = aiohttp.FormData()
         data.add_field(
             name='file',
-            value=tfile.content,
-            filename=tfile.filename.as_posix(),
-            content_type=tfile.content_type,
+            value=file.content,
+            filename=file.filename.as_posix(),
+            content_type=file.content_type,
         )
         data.add_field(
             name='fileName',
-            value=tfile.filename.as_posix(),
+            value=file.filename.as_posix(),
         )
         async with self.session.post(
                 f'{self.api_url}/document-template-drafts/{remote_id}/assets',
@@ -313,30 +319,30 @@ class DSWAPIClient:
         ) as r:
             self._check_status(r, expected_status=201)
             body = await r.json()
-            return _load_remote_asset(body, tfile.content)
+            return _load_remote_asset(body, file.content)
 
     @handle_client_errors
-    async def put_template_draft_asset_content(self, remote_id: str, tfile: TemplateFile):
+    async def put_template_draft_asset_content(self, remote_id: str, file: TemplateFile):
         data = aiohttp.FormData()
         data.add_field(
             name='file',
-            value=tfile.content,
-            filename=tfile.filename.as_posix(),
-            content_type=tfile.content_type,
+            value=file.content,
+            filename=file.filename.as_posix(),
+            content_type=file.content_type,
         )
         data.add_field(
             name='fileName',
-            value=tfile.filename.as_posix(),
+            value=file.filename.as_posix(),
         )
         async with self.session.put(
                 f'{self.api_url}/document-template-drafts/{remote_id}'
-                f'/assets/{tfile.remote_id}/content',
+                f'/assets/{file.remote_id}/content',
                 data=data,
                 headers=self._headers()
         ) as r:
             self._check_status(r, expected_status=200)
             body = await r.json()
-            return _load_remote_asset(body, tfile.content)
+            return _load_remote_asset(body, file.content)
 
     @handle_client_errors
     async def delete_template_draft(self, remote_id: str) -> bool:
@@ -368,25 +374,25 @@ class DSWAPIClient:
 def _load_remote_file(data: dict) -> TemplateFile:
     content: str = data.get('content', '')
     filename: str = str(data.get('fileName', ''))
-    template_file = TemplateFile(
+    file = TemplateFile(
         remote_id=data.get('uuid', None),
         remote_type=TemplateFileType.FILE,
         filename=pathlib.Path(urllib.parse.unquote(filename)),
         content=content.encode(encoding=DEFAULT_ENCODING),
     )
-    return template_file
+    return file
 
 
 def _load_remote_asset(data: dict, content: bytes) -> TemplateFile:
     filename = str(data.get('fileName', ''))
-    template_file = TemplateFile(
+    asset = TemplateFile(
         remote_id=data.get('uuid', None),
         remote_type=TemplateFileType.ASSET,
         filename=pathlib.Path(urllib.parse.unquote(filename)),
         content_type=data.get('contentType', None),
         content=content,
     )
-    return template_file
+    return asset
 
 
 def _load_remote_template(data: dict) -> Template:

dsw/tdk/build_info.py

@@ -9,9 +9,9 @@ BuildInfo = namedtuple(
 )
 
 BUILD_INFO = BuildInfo(
-    version='v4.20.1~0e2ea82',
-    built_at='2025-07-23 08:04:35Z',
-    sha='0e2ea82aa69b9aae205f7715cf9606bbf75f9f20',
+    version='v4.22.0~dffe6c1',
+    built_at='2025-09-02 13:01:04Z',
+    sha='dffe6c10e47b8795a0d27d495d1c0c0a5d4a76fb',
     branch='HEAD',
-    tag='v4.20.1',
+    tag='v4.22.0',
 )

dsw/tdk/cli.py

@@ -8,16 +8,16 @@ import signal
 import sys
 
 import click
-import dotenv
 import humanize
 import slugify
 import watchfiles
 
-from .api_client import DSWCommunicationError
+from .api_client import WizardCommunicationError
+from .config import CONFIG
+from .consts import VERSION, DEFAULT_LIST_FORMAT, DEFAULT_ENCODING
 from .core import TDKCore, TDKProcessingError
-from .consts import VERSION, DEFAULT_LIST_FORMAT
 from .model import Template
-from .utils import TemplateBuilder, FormatSpec, safe_utf8
+from .utils import TemplateBuilder, FormatSpec, safe_utf8, create_dot_env
 from .validation import ValidationError
 
 CURRENT_DIR = pathlib.Path.cwd()
@@ -89,19 +89,29 @@ def print_template_info(template: Template):
     for format_spec in template.formats:
         click.echo(f' - {format_spec.name}')
     click.echo('Files:')
-    for tfile in template.files.values():
-        filesize = humanize.naturalsize(len(tfile.content))
-        click.echo(f' - {tfile.filename.as_posix()} [{filesize}]')
-
-
-# pylint: disable-next=unused-argument
-def rectify_url(ctx, param, value) -> str:
-    return value.rstrip('/')
-
-
-# pylint: disable-next=unused-argument
-def rectify_key(ctx, param, value) -> str:
-    return value.strip()
+    for template_file in template.files.values():
+        filesize = humanize.naturalsize(len(template_file.content))
+        click.echo(f' - {template_file.filename.as_posix()} [{filesize}]')
+
+
+def ensure_api_config(api_url: str | None, api_key: str | None):
+    if api_url is not None:
+        CONFIG.use_local_env()
+        CONFIG.set_api_url(api_url)
+    if not CONFIG.has_api_url:
+        CONFIG.set_api_url(
+            api_url=click.prompt('API URL'),
+        )
+    if api_key is not None:
+        CONFIG.use_local_env()
+        CONFIG.set_api_key(api_key)
+    if not CONFIG.has_api_key:
+        CONFIG.set_api_key(
+            api_key=click.prompt('API Key', hide_input=True),
+        )
+    if not CONFIG.has_api_url or not CONFIG.has_api_key:
+        ClickPrinter.error('API URL and API Key are required to proceed.')
+        sys.exit(1)
 
 
 class ClickLogger(logging.Logger):
@@ -244,18 +254,38 @@ def dir_from_id(template_id: str) -> pathlib.Path:
 
 
 @click.group(cls=AliasedGroup)
-@click.option('-e', '--dot-env', default='.env', required=False,
+@click.option('-d', '--dot-env', default='.env', required=False,
               show_default=True, type=click.Path(file_okay=True, dir_okay=False),
-              help='Provide file with environment variables.')
+              help='File path to dot-env file with environment variables.')
+@click.option('-e', '--environment', default=None, required=False,
+              help='Configuration environment name.')
+@click.option('--no-dot-env', is_flag=True, default=False,
+              help='Do not load .env file, use only environment variables.')
+@click.option('--no-config', is_flag=True, default=False,
+              help='Do not load shared configuration, use only environment variables.')
 @click.option('-q', '--quiet', is_flag=True,
               help='Hide additional information logs.')
 @click.option('--debug', is_flag=True,
               help='Enable debug logging.')
 @click.version_option(version=VERSION)
 @click.pass_context
-def main(ctx, quiet, debug, dot_env):
-    if pathlib.Path(dot_env).exists():
-        dotenv.load_dotenv(dotenv_path=dot_env)
+def main(ctx, quiet, debug, dot_env, environment, no_dot_env, no_config):
+    if not no_config:
+        try:
+            CONFIG.load_home_config()
+        except Exception as e:
+            ClickPrinter.warning('Failed to load shared configuration')
+            ClickPrinter.warning(f'> {e}')
+    if not no_dot_env and dot_env is not None:
+        dot_env_path = pathlib.Path(dot_env)
+        if dot_env_path.exists():
+            CONFIG.load_dotenv(path=dot_env_path)
+    try:
+        if environment is not None:
+            CONFIG.switch_current_env(environment)
+    except Exception as e:
+        ClickPrinter.warning('Failed to set config environment')
+        ClickPrinter.warning(f'> {e}')
     ctx.ensure_object(CLIContext)
     ctx.obj.dot_env_file = dot_env
     if quiet:
@@ -292,13 +322,13 @@ def new_template(ctx, template_dir, force):
 @click.argument('TEMPLATE-ID')
 @click.argument('TEMPLATE-DIR', type=NEW_DIR_TYPE, default=None, required=False)
 @click.option('-u', '--api-url', metavar='API-URL', envvar='DSW_API_URL',
-              prompt='API URL', help='URL of Wizard server API.', callback=rectify_url)
+              help='URL of Wizard server API.')
 @click.option('-k', '--api-key', metavar='API-KEY', envvar='DSW_API_KEY',
-              prompt='API Key', help='API key for Wizard instance.', callback=rectify_key,
-              hide_input=True)
+              help='API key for Wizard instance.')
 @click.option('-f', '--force', is_flag=True, help='Overwrite any existing files.')
 @click.pass_context
-def get_template(ctx, api_url, template_id, template_dir, api_key, force):
+def get_template(ctx, template_id, template_dir, api_url, api_key, force):
+    ensure_api_config(api_url, api_key)
     template_dir = pathlib.Path(template_dir or dir_from_id(template_id))
 
     async def main_routine():
@@ -306,7 +336,10 @@ def get_template(ctx, api_url, template_id, template_dir, api_key, force):
         template_type = 'unknown'
         zip_data = None
         try:
-            await tdk.init_client(api_url=api_url, api_key=api_key)
+            await tdk.init_client(
+                api_url=CONFIG.env.api_url,
+                api_key=CONFIG.env.api_key,
+            )
             try:
                 await tdk.load_remote(template_id=template_id)
                 template_type = 'draft'
@@ -314,7 +347,7 @@ def get_template(ctx, api_url, template_id, template_dir, api_key, force):
                 zip_data = await tdk.download_bundle(template_id=template_id)
                 template_type = 'bundle'
             await tdk.safe_client.close()
-        except DSWCommunicationError as e:
+        except WizardCommunicationError as e:
             ClickPrinter.error('Could not get template:', bold=True)
             ClickPrinter.error(f'> {e.reason}\n> {e.message}')
             await tdk.safe_client.close()
@@ -352,16 +385,16 @@ def get_template(ctx, api_url, template_id, template_dir, api_key, force):
 @main.command(help='Upload template to Wizard.', name='put')
 @click.argument('TEMPLATE-DIR', type=DIR_TYPE, default=CURRENT_DIR, required=False)
 @click.option('-u', '--api-url', metavar='API-URL', envvar='DSW_API_URL',
-              prompt='API URL', help='URL of Wizard server API.', callback=rectify_url)
+              help='URL of Wizard server API.')
 @click.option('-k', '--api-key', metavar='API-KEY', envvar='DSW_API_KEY',
-              prompt='API Key', help='API key for Wizard instance.', callback=rectify_key,
-              hide_input=True)
+              help='API key for Wizard instance.')
 @click.option('-f', '--force', is_flag=True,
               help='Delete template if already exists.')
 @click.option('-w', '--watch', is_flag=True,
               help='Enter watch mode to continually upload changes.')
 @click.pass_context
-def put_template(ctx, api_url, template_dir, api_key, force, watch):
+def put_template(ctx, template_dir, api_url, api_key, force, watch):
+    ensure_api_config(api_url, api_key)
     tdk = TDKCore(logger=ctx.obj.logger)
     stop_event = asyncio.Event()
 
@@ -379,7 +412,10 @@ def put_template(ctx, api_url, template_dir, api_key, force, watch):
     async def main_routine():
         load_local(tdk, template_dir)
         try:
-            await tdk.init_client(api_url=api_url, api_key=api_key)
+            await tdk.init_client(
+                api_url=CONFIG.env.api_url,
+                api_key=CONFIG.env.api_key,
+            )
             await tdk.store_remote(force=force)
             ClickPrinter.success(f'Template {tdk.safe_project.safe_template.id} '
                                  f'uploaded to {api_url}')
@@ -394,7 +430,7 @@ def put_template(ctx, api_url, template_dir, api_key, force, watch):
             ClickPrinter.error(f'> {e.message}\n> {e.hint}')
             await tdk.safe_client.safe_close()
             sys.exit(1)
-        except DSWCommunicationError as e:
+        except WizardCommunicationError as e:
             ClickPrinter.failure('Could not upload template')
             ClickPrinter.error(f'> {e.reason}\n> {e.message}')
             ClickPrinter.error('> Probably incorrect API URL, metamodel version, '
@@ -404,9 +440,9 @@ def put_template(ctx, api_url, template_dir, api_key, force, watch):
             sys.exit(1)
 
     # pylint: disable-next=unused-argument
-    def set_stop_event(signum, frame):
-        signame = signal.Signals(signum).name
-        ClickPrinter.warning(f'Got {signame}, finishing... Bye!')
+    def set_stop_event(signal_num, frame):
+        signal_name = signal.Signals(signal_num).name
+        ClickPrinter.warning(f'Got {signal_name}, finishing... Bye!')
         stop_event.set()
 
     signal.signal(signal.SIGINT, set_stop_event)
@@ -460,10 +496,9 @@ def extract_package(ctx, template_package, output, force: bool):
 
 @main.command(help='List templates from Wizard via API.', name='list')
 @click.option('-u', '--api-url', metavar='API-URL', envvar='DSW_API_URL',
-              prompt='API URL', help='URL of Wizard server API.', callback=rectify_url)
+              help='URL of Wizard server API.')
 @click.option('-k', '--api-key', metavar='API-KEY', envvar='DSW_API_KEY',
-              prompt='API Key', help='API key for Wizard instance.', callback=rectify_key,
-              hide_input=True)
+              help='API key for Wizard instance.')
 @click.option('--output-format', default=DEFAULT_LIST_FORMAT,
               metavar='FORMAT', help='Entry format string for printing.')
 @click.option('-r', '--released-only', is_flag=True, help='List only released templates')
@@ -471,10 +506,15 @@ def extract_package(ctx, template_package, output, force: bool):
 @click.pass_context
 def list_templates(ctx, api_url, api_key, output_format: str,
                    released_only: bool, drafts_only: bool):
+    ensure_api_config(api_url, api_key)
+
     async def main_routine():
         tdk = TDKCore(logger=ctx.obj.logger)
         try:
-            await tdk.init_client(api_url=api_url, api_key=api_key)
+            await tdk.init_client(
+                api_url=CONFIG.env.api_url,
+                api_key=CONFIG.env.api_key,
+            )
             if released_only:
                 templates = await tdk.list_remote_templates()
                 for template in templates:
@@ -494,7 +534,7 @@ def list_templates(ctx, api_url, api_key, output_format: str,
                     click.echo(output_format.format(template=template))
             await tdk.safe_client.safe_close()
 
-        except DSWCommunicationError as e:
+        except WizardCommunicationError as e:
             ClickPrinter.failure('Failed to get list of templates')
             ClickPrinter.error(f'> {e.reason}\n> {e.message}')
             await tdk.safe_client.safe_close()
@@ -521,24 +561,141 @@ def verify_template(ctx, template_dir):
             click.echo(f' - {err.field_name}: {err.message}')
 
 
-@main.command(help='Create a .env file.', name='dot-env')
+@main.group(help='Manage shared user configuration (~/.dsw-tdk).', name='config')
+@click.pass_context
+# pylint: disable-next=unused-argument
+def config(ctx):
+    pass
+
+
+@config.command(name='init', help='Initialize the shared user configuration (~/.dsw-tdk).')
+@click.option('-f', '--force', is_flag=True, help='Overwrite file if already exists.')
+def config_init(force):
+    if CONFIG.HOME_CONFIG.exists() and not force:
+        ClickPrinter.error('Configuration file already exists. Use `--force` to overwrite it.')
+        sys.exit(1)
+    CONFIG.shared_envs.clear()
+    CONFIG.default_env_name = None
+
+    click.echo('You need to specify your first environment name (default one).')
+    click.echo('Recommendation: use short and lowercase name, e.g. "production"')
+    environment = click.prompt('Environment name', default='production')
+    api_url = click.prompt('API URL')
+    api_key = click.prompt('API Key', hide_input=True)
+    try:
+        CONFIG.add_shared_env(
+            name=environment,
+            api_url=api_url,
+            api_key=api_key,
+        )
+        CONFIG.default_env_name = environment
+    except Exception as e:
+        ClickPrinter.failure('Failed to add environment')
+        ClickPrinter.error(f'> {e}')
+        sys.exit(1)
+    while True:
+        add_another = click.confirm('Do you want to add another environment?', default=False)
+        if not add_another:
+            break
+        environment = click.prompt('Environment name')
+        api_url = click.prompt('API URL')
+        api_key = click.prompt('API Key', hide_input=True)
+        try:
+            CONFIG.add_shared_env(
+                name=environment,
+                api_url=api_url,
+                api_key=api_key,
+            )
+        except Exception as e:
+            ClickPrinter.failure('Failed to add environment (skipping)')
+            ClickPrinter.warning(f'> {e}')
+
+    try:
+        CONFIG.persist(force=force)
+        ClickPrinter.success('Configuration initialized successfully.')
+    except Exception as e:
+        ClickPrinter.failure('Failed to initialize configuration')
+        ClickPrinter.error(f'> {e}')
+        sys.exit(1)
+
+
+@config.command(name='edit', help='Edit the shared user configuration (~/.dsw-tdk).')
+@click.option('-f', '--force', is_flag=True, help='Create file if does not exist.')
+def config_edit(force):
+    if not CONFIG.HOME_CONFIG.exists():
+        if force:
+            CONFIG.HOME_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+            CONFIG.HOME_CONFIG.touch()
+        else:
+            ClickPrinter.error('Configuration file does not exist. Use `init` command '
+                               'or `--force` flag to create it.')
+            sys.exit(1)
+    click.edit(
+        filename=str(CONFIG.HOME_CONFIG),
+        extension='.cfg',
+        require_save=True,
+    )
+
+
+@config.command(name='check', help='Check the current configuration that can be loaded.')
+def config_check():
+    hidden = click.style('(hidden)', fg='red', bold=True)
+    not_set = click.style('(not set)', fg='yellow', bold=True)
+    click.secho('Shared configuration (~/.dsw-tdk):', bold=True)
+    for env_name, env in CONFIG.shared_envs.items():
+        if env_name == CONFIG.current_env_name:
+            env_out = click.style(env_name, fg='green', bold=True)
+            click.echo(f'{env_out} (current)')
+        elif env_name == CONFIG.default_env_name:
+            env_out = click.style(env_name, fg='cyan', bold=True)
+            click.echo(f'{env_out} (default)')
+        else:
+            env_out = click.style(env_name, fg='blue', bold=True)
+            click.echo(env_out)
+        click.echo(f'  API URL: {env.api_url if env.api_url else not_set}')
+        click.echo(f'  API Key: {hidden if env.api_key else not_set}')
+    click.echo('')
+    click.secho('Project-local configuration:', bold=True)
+    if CONFIG.current_env_name == CONFIG.LOCAL_CONFIG:
+        env_out = click.style(CONFIG.LOCAL_CONFIG, fg='green', bold=True)
+        click.echo(f'{env_out} (current)')
+    else:
+        env_out = click.style('local', fg='blue', bold=True)
+        click.echo(env_out)
+    if CONFIG.local_env.api_url:
+        click.echo(f'  API URL: {CONFIG.local_env.api_url}')
+    else:
+        click.echo(f'  API URL: {not_set}')
+    if CONFIG.local_env.api_key:
+        click.echo(f'  API Key: {hidden}')
+    else:
+        click.echo(f'  API Key: {not_set}')
+
+
+@config.command(name='dot-env', help='Create a .env file with API configuration.')
 @click.argument('TEMPLATE-DIR', type=DIR_TYPE, default=CURRENT_DIR, required=False)
 @click.option('-u', '--api-url', metavar='API-URL', envvar='DSW_API_URL',
-              prompt='API URL', help='URL of Wizard server API.', callback=rectify_url)
+              help='URL of Wizard server API.')
 @click.option('-k', '--api-key', metavar='API-KEY', envvar='DSW_API_KEY',
-              prompt='API Key', help='API key for Wizard instance.', callback=rectify_key,
-              hide_input=True)
+              help='API key for Wizard instance.')
 @click.option('-f', '--force', is_flag=True, help='Overwrite file if already exists.')
 @click.pass_context
-def create_dot_env(ctx, template_dir, api_url, api_key, force):
+def config_create_dotenv(ctx, template_dir, api_url, api_key, force):
+    ensure_api_config(api_url, api_key)
     filename = ctx.obj.dot_env_file or '.env'
-    tdk = TDKCore(logger=ctx.obj.logger)
+    output = pathlib.Path(template_dir) / filename
     try:
-        tdk.create_dot_env(
-            output=pathlib.Path(template_dir) / filename,
-            force=force,
-            api_url=api_url,
-            api_key=api_key,
+        if output.exists():
+            if force:
+                ClickPrinter.warning(f'Overwriting {output.as_posix()} (forced)', )
+            else:
+                raise FileExistsError(f'File {output.as_posix()} already exists (not forced)')
+        output.write_text(
+            data=create_dot_env(
+                api_url=CONFIG.env.api_url,
+                api_key=CONFIG.env.api_key,
+            ),
+            encoding=DEFAULT_ENCODING,
         )
     except Exception as e:
         ClickPrinter.failure('Failed to create dot-env file')