dsw-tdk 4.13.0__py2.py3-none-any.whl → 4.14.0__py2.py3-none-any.whl

dsw/tdk/core.py

@@ -7,11 +7,9 @@ import pathlib
 import re
 import shutil
 import tempfile
-import watchfiles  # type: ignore
 import zipfile
 
-
-from typing import List, Optional, Tuple
+import watchfiles
 
 from .api_client import DSWAPIClient, DSWCommunicationError
 from .consts import DEFAULT_ENCODING, REGEX_SEMVER
@@ -20,7 +18,7 @@ from .utils import UUIDGen, create_dot_env
 from .validation import ValidationError, TemplateValidator
 
 
-ChangeItem = Tuple[watchfiles.Change, pathlib.Path]
+ChangeItem = tuple[watchfiles.Change, pathlib.Path]
 
 
 def _change(item: ChangeItem, root: pathlib.Path) -> str:
@@ -54,6 +52,7 @@ METAMODEL_VERSION_SUPPORT = {
 }
 
 
+# pylint: disable=too-many-public-methods
 class TDKCore:
 
     def _check_metamodel_version(self):
@@ -64,24 +63,24 @@ class TDKCore:
         if 'v' == api_version[0]:
             api_version = api_version[1:]
         if not re.match(REGEX_SEMVER, api_version):
-            self.logger.warning(f'Using non-stable release of API: {self.remote_version}')
+            self.logger.warning('Using non-stable release of API: %s', self.remote_version)
             return
         parts = api_version.split('.')
         ver = (int(parts[0]), int(parts[1]), int(parts[2]))
         vtag = f'v{ver[0]}.{ver[1]}.{ver[2]}'
         hint = 'Fix your metamodelVersion in template.json and/or visit docs'
-        if mm_ver not in METAMODEL_VERSION_SUPPORT.keys():
+        if mm_ver not in METAMODEL_VERSION_SUPPORT:
             raise TDKProcessingError(f'Unknown metamodel version: {mm_ver}', hint)
         min_version = METAMODEL_VERSION_SUPPORT[mm_ver]
         if min_version > ver:
             raise TDKProcessingError(f'Unsupported metamodel version for API {vtag}', hint)
-        if mm_ver + 1 in METAMODEL_VERSION_SUPPORT.keys():
+        if mm_ver + 1 in METAMODEL_VERSION_SUPPORT:
             max_version = METAMODEL_VERSION_SUPPORT[mm_ver + 1]
             if ver >= max_version:
                 raise TDKProcessingError(f'Unsupported metamodel version for API {vtag}', hint)
 
-    def __init__(self, template: Optional[Template] = None, project: Optional[TemplateProject] = None,
-                 client: Optional[DSWAPIClient] = None, logger: Optional[logging.Logger] = None):
+    def __init__(self, template: Template | None = None, project: TemplateProject | None = None,
+                 client: DSWAPIClient | None = None, logger: logging.Logger | None = None):
         self.template = template
         self.project = project
         self.client = client
@@ -113,13 +112,13 @@ class TDKCore:
         return self.client
 
     async def init_client(self, api_url: str, api_key: str):
-        self.logger.info(f'Connecting to {api_url}')
+        self.logger.info('Connecting to %s', api_url)
         self.client = DSWAPIClient(api_url=api_url, api_key=api_key)
         self.remote_version = await self.client.get_api_version()
         user = await self.client.get_current_user()
-        self.logger.info(f'Successfully authenticated as {user["firstName"]} '
-                         f'{user["lastName"]} ({user["email"]})')
-        self.logger.debug(f'Connected to API version {self.remote_version}')
+        self.logger.info('Successfully authenticated as %s %s (%s)',
+                         user['firstName'], user['lastName'], user['email'])
+        self.logger.debug('Connected to API version %s', self.remote_version)
 
     def prepare_local(self, template_dir):
         self.logger.debug('Preparing local template project')
@@ -131,32 +130,32 @@ class TDKCore:
         self.safe_project.load()
 
     async def load_remote(self, template_id: str):
-        self.logger.info(f'Retrieving template draft {template_id}')
+        self.logger.info('Retrieving template draft %s', template_id)
         self.template = await self.safe_client.get_template_draft(remote_id=template_id)
         self.logger.debug('Retrieving template draft files')
         files = await self.safe_client.get_template_draft_files(remote_id=template_id)
-        self.logger.info(f'Retrieved {len(files)} file(s)')
+        self.logger.info('Retrieved %s file(s)', len(files))
         for tfile in files:
             self.safe_template.files[tfile.filename.as_posix()] = tfile
         self.logger.debug('Retrieving template draft assets')
         assets = await self.safe_client.get_template_draft_assets(remote_id=template_id)
-        self.logger.info(f'Retrieved {len(assets)} asset(s)')
+        self.logger.info('Retrieved %s asset(s)', len(assets))
         for tfile in assets:
             self.safe_template.files[tfile.filename.as_posix()] = tfile
 
     async def download_bundle(self, template_id: str) -> bytes:
-        self.logger.info(f'Retrieving template {template_id} bundle')
+        self.logger.info('Retrieving template %s bundle', template_id)
         return await self.safe_client.get_template_bundle(remote_id=template_id)
 
-    async def list_remote_templates(self) -> List[Template]:
+    async def list_remote_templates(self) -> list[Template]:
         self.logger.info('Listing remote document templates')
         return await self.safe_client.get_templates()
 
-    async def list_remote_drafts(self) -> List[Template]:
+    async def list_remote_drafts(self) -> list[Template]:
         self.logger.info('Listing remote document template drafts')
         return await self.safe_client.get_drafts()
 
-    def verify(self) -> List[ValidationError]:
+    def verify(self) -> list[ValidationError]:
         template = self.template or self.safe_project.template
         if template is None:
             raise RuntimeError('No template is loaded')
@@ -166,7 +165,7 @@ class TDKCore:
         if self.project is None:
             raise RuntimeError('No template project is initialized')
         self.project.template = self.safe_template
-        self.logger.debug(f'Initiating storing local template project (force={force})')
+        self.logger.debug('Initiating storing local template project (force=%s)', force)
         self.project.store(force=force)
 
     async def store_remote(self, force: bool):
@@ -174,8 +173,9 @@ class TDKCore:
         self._check_metamodel_version()
         org_id = await self.safe_client.get_organization_id()
         if org_id != self.safe_template.organization_id:
-            self.logger.warning(f'There is different organization ID set in the DSW instance'
-                                f' (local: {self.safe_template.organization_id}, remote: {org_id})')
+            self.logger.warning('There is different organization ID set in the DSW instance'
+                                ' (local: %s, remote: %s)',
+                                self.safe_template.organization_id, org_id)
         self.remote_id = self.safe_template.id_with_org(org_id)
         template_exists = await self.safe_client.check_draft_exists(remote_id=self.remote_id)
         if template_exists and force:
@@ -186,26 +186,39 @@ class TDKCore:
             template_exists = not result
 
         if template_exists:
-            # TODO: do not remove if not necessary (make diff?)
             self.logger.info('Updating existing remote document template draft')
-            await self.safe_client.update_template_draft(template=self.safe_template, remote_id=self.remote_id)
+            await self.safe_client.update_template_draft(
+                template=self.safe_template,
+                remote_id=self.remote_id,
+            )
             self.logger.debug('Retrieving remote assets')
-            remote_assets = await self.safe_client.get_template_draft_assets(remote_id=self.remote_id)
+            remote_assets = await self.safe_client.get_template_draft_assets(
+                remote_id=self.remote_id,
+            )
             self.logger.debug('Retrieving remote files')
-            remote_files = await self.safe_client.get_template_draft_files(remote_id=self.remote_id)
-            await self.cleanup_remote_files(remote_assets=remote_assets, remote_files=remote_files)
+            remote_files = await self.safe_client.get_template_draft_files(
+                remote_id=self.remote_id,
+            )
+            await self.cleanup_remote_files(
+                remote_assets=remote_assets,
+                remote_files=remote_files,
+            )
         else:
             self.logger.info('Creating remote document template draft')
-            await self.safe_client.create_new_template_draft(template=self.safe_template, remote_id=self.remote_id)
+            await self.safe_client.create_new_template_draft(
+                template=self.safe_template,
+                remote_id=self.remote_id,
+            )
         await self.store_remote_files()
 
     async def _update_template_file(self, remote_tfile: TemplateFile, local_tfile: TemplateFile,
                                     project_update: bool = False):
         try:
-            self.logger.debug(f'Updating existing remote {remote_tfile.remote_type.value} '
-                              f'{remote_tfile.filename.as_posix()} ({remote_tfile.remote_id}) started')
+            self.logger.debug('Updating existing remote %s %s (%s) started',
+                              remote_tfile.remote_type.value, remote_tfile.filename.as_posix(),
+                              remote_tfile.remote_id)
             local_tfile.remote_id = remote_tfile.remote_id
-            if remote_tfile.remote_type == TemplateFileType.asset:
+            if remote_tfile.remote_type == TemplateFileType.ASSET:
                 result = await self.safe_client.put_template_draft_asset_content(
                     remote_id=self.remote_id,
                     tfile=local_tfile,
@@ -215,25 +228,27 @@ class TDKCore:
                     remote_id=self.remote_id,
                     tfile=local_tfile,
                 )
-            self.logger.debug(f'Updating existing remote {remote_tfile.remote_type.value} '
-                              f'{remote_tfile.filename.as_posix()} ({remote_tfile.remote_id}) '
-                              f'finished: {"ok" if result else "failed"}')
+            self.logger.debug('Updating existing remote %s %s (%s) finished: %s',
+                              remote_tfile.remote_type.value, remote_tfile.filename.as_posix(),
+                              remote_tfile.remote_id, 'ok' if result else 'failed')
             if project_update and result:
                 self.safe_project.update_template_file(result)
-        except Exception as e:
+        except Exception as e1:
             try:
-                self.logger.debug(f'Trying to delete/create due to: {str(e)}')
+                self.logger.debug('Trying to delete/create due to: %s', str(e1))
                 await self._delete_template_file(tfile=remote_tfile)
                 await self._create_template_file(tfile=local_tfile, project_update=True)
-            except Exception as e:
-                self.logger.error(f'Failed to update existing remote {remote_tfile.remote_type.value} '
-                                  f'{remote_tfile.filename.as_posix()}: {e}')
+            except Exception as e2:
+                self.logger.error('Failed to update existing remote %s %s: %s',
+                                  remote_tfile.remote_type.value,
+                                  remote_tfile.filename.as_posix(), e2)
 
     async def _delete_template_file(self, tfile: TemplateFile, project_update: bool = False):
         try:
-            self.logger.debug(f'Deleting existing remote {tfile.remote_type.value} '
-                              f'{tfile.filename.as_posix()} ({tfile.remote_id}) started')
-            if tfile.remote_type == TemplateFileType.asset:
+            self.logger.debug('Deleting existing remote %s %s (%s) started',
+                              tfile.remote_type.value, tfile.filename.as_posix(),
+                              tfile.remote_id)
+            if tfile.remote_type == TemplateFileType.ASSET:
                 result = await self.safe_client.delete_template_draft_asset(
                     remote_id=self.remote_id,
                     asset_id=tfile.remote_id,
@@ -243,18 +258,19 @@ class TDKCore:
                     remote_id=self.remote_id,
                     file_id=tfile.remote_id,
                 )
-            self.logger.debug(f'Deleting existing remote {tfile.remote_type.value} '
-                              f'{tfile.filename.as_posix()} ({tfile.remote_id}) '
-                              f'finished: {"ok" if result else "failed"}')
+            self.logger.debug('Deleting existing remote %s %s (%s) finished: %s',
+                              tfile.remote_type.value, tfile.filename.as_posix(),
+                              tfile.remote_id, 'ok' if result else 'failed')
             if project_update and result:
                 self.safe_project.remove_template_file(tfile.filename)
         except Exception as e:
-            self.logger.error(f'Failed to delete existing remote {tfile.remote_type.value} '
-                              f'{tfile.filename.as_posix()}: {e}')
+            self.logger.error('Failed to delete existing remote %s %s: %s',
+                              tfile.remote_type.value, tfile.filename.as_posix(), e)
 
-    async def cleanup_remote_files(self, remote_assets: List[TemplateFile], remote_files: List[TemplateFile]):
+    async def cleanup_remote_files(self, remote_assets: list[TemplateFile],
+                                   remote_files: list[TemplateFile]):
         for tfile in self.safe_project.safe_template.files.values():
-            self.logger.debug(f'Cleaning up remote {tfile.filename.as_posix()}')
+            self.logger.debug('Cleaning up remote %s', tfile.filename.as_posix())
             for remote_asset in remote_assets:
                 if remote_asset.filename == tfile.filename:
                     await self._delete_template_file(tfile=remote_asset, project_update=False)
@@ -264,60 +280,68 @@ class TDKCore:
 
     async def _create_template_file(self, tfile: TemplateFile, project_update: bool = False):
         try:
-            self.logger.debug(f'Storing remote {tfile.remote_type.value} '
-                              f'{tfile.filename.as_posix()} started')
-            if tfile.remote_type == TemplateFileType.asset:
-                result = await self.safe_client.post_template_draft_asset(remote_id=self.remote_id, tfile=tfile)
+            self.logger.debug('Storing remote %s %s started',
+                              tfile.remote_type.value, tfile.filename.as_posix())
+            if tfile.remote_type == TemplateFileType.ASSET:
+                result = await self.safe_client.post_template_draft_asset(
+                    remote_id=self.remote_id,
+                    tfile=tfile,
+                )
             else:
-                result = await self.safe_client.post_template_draft_file(remote_id=self.remote_id, tfile=tfile)
-            self.logger.debug(f'Storing remote {tfile.remote_type.value} '
-                              f'{tfile.filename.as_posix()} finished: {result.remote_id}')
+                result = await self.safe_client.post_template_draft_file(
+                    remote_id=self.remote_id,
+                    tfile=tfile,
+                )
+            self.logger.debug('Storing remote %s %s finished: %s',
+                              tfile.remote_type.value, tfile.filename.as_posix(), result.remote_id)
             if project_update and result is not None:
                 self.safe_project.update_template_file(result)
         except Exception as e:
-            self.logger.error(f'Failed to store remote {tfile.remote_type.value} {tfile.filename.as_posix()}: {str(e)}')
+            self.logger.error('Failed to store remote %s %s: %s',
+                              tfile.remote_type.value, tfile.filename.as_posix(), e)
 
     async def store_remote_files(self):
         for tfile in self.safe_project.safe_template.files.values():
             tfile.remote_id = None
-            tfile.remote_type = TemplateFileType.file if tfile.is_text else TemplateFileType.asset
+            tfile.remote_type = TemplateFileType.FILE if tfile.is_text else TemplateFileType.ASSET
             await self._create_template_file(tfile=tfile, project_update=True)
 
     def create_package(self, output: pathlib.Path, force: bool):
         if output.exists() and not force:
             raise RuntimeError(f'File {output} already exists (not forced)')
-        self.logger.debug(f'Opening ZIP file for write: {output}')
+        self.logger.debug('Opening ZIP file for write: %s', output.as_posix())
         with zipfile.ZipFile(output, mode='w', compression=zipfile.ZIP_DEFLATED) as pkg:
             descriptor = self.safe_project.safe_template.serialize_remote()
             files = []
             assets = []
             for tfile in self.safe_project.safe_template.files.values():
                 if tfile.is_text:
-                    self.logger.info(f'Adding template file {tfile.filename.as_posix()}')
+                    self.logger.info('Adding template file %s', tfile.filename.as_posix())
                     files.append({
                         'uuid': str(UUIDGen.generate()),
                         'content': tfile.content.decode(encoding=DEFAULT_ENCODING),
                         'fileName': str(tfile.filename.as_posix()),
                     })
                 else:
-                    self.logger.info(f'Adding template asset {tfile.filename.as_posix()}')
+                    self.logger.info('Adding template asset %s', tfile.filename.as_posix())
                     assets.append({
                         'uuid': str(UUIDGen.generate()),
                         'contentType': tfile.content_type,
                         'fileName': str(tfile.filename.as_posix()),
                     })
-                    self.logger.debug(f'Packaging template asset {tfile.filename}')
+                    self.logger.debug('Packaging template asset %s', tfile.filename.as_posix())
                     pkg.writestr(f'template/assets/{tfile.filename.as_posix()}', tfile.content)
             descriptor['files'] = files
             descriptor['assets'] = assets
-            timestamp = datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%S.%fZ')
+            timestamp = datetime.datetime.now(tz=datetime.UTC).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
             descriptor['createdAt'] = timestamp
             descriptor['updatedAt'] = timestamp
             self.logger.debug('Packaging template.json file')
             pkg.writestr('template/template.json', data=json.dumps(descriptor, indent=4))
         self.logger.debug('ZIP packaging done')
 
-    def extract_package(self, zip_data: bytes, template_dir: Optional[pathlib.Path], force: bool):
+    # pylint: disable=too-many-locals
+    def extract_package(self, zip_data: bytes, template_dir: pathlib.Path | None, force: bool):
         with tempfile.TemporaryDirectory() as tmp_dir:
             io_zip = io.BytesIO(zip_data)
             with zipfile.ZipFile(io_zip) as pkg:
@@ -373,7 +397,7 @@ class TDKCore:
     def create_dot_env(self, output: pathlib.Path, force: bool, api_url: str, api_key: str):
         if output.exists():
             if force:
-                self.logger.warning(f'Overwriting {output.as_posix()} (forced)')
+                self.logger.warning('Overwriting %s (forced)', output.as_posix())
             else:
                 raise RuntimeError(f'File {output} already exists (not forced)')
         output.write_text(
@@ -393,47 +417,49 @@ class TDKCore:
                 )
             ))
 
-    async def _update_descriptor(self):
+    async def update_descriptor(self):
         try:
             template_exists = await self.safe_client.check_draft_exists(
                 remote_id=self.remote_id,
             )
             if template_exists:
-                self.logger.info(f'Updating existing remote document template draft'
-                                 f' {self.safe_project.safe_template.id}')
+                self.logger.info('Updating existing remote document template draft %s',
+                                 self.safe_project.safe_template.id)
                 await self.safe_client.update_template_draft(
                     template=self.safe_project.safe_template,
                     remote_id=self.remote_id,
                 )
             else:
-                # TODO: optimization - reload full template and send it, skip all other changes
-                self.logger.info(f'Document template draft {self.safe_project.safe_template.id} '
-                                 f'does not exist on remote - full sync')
+                self.logger.info('Document template draft %s does not exist on remote - full sync',
+                                 self.safe_project.safe_template.id)
                 await self.store_remote(force=False)
         except DSWCommunicationError as e:
-            self.logger.error(f'Failed to update document template draft'
-                              f' {self.safe_project.safe_template.id}: {e.message}')
+            self.logger.error('Failed to update document template draft %s: %s',
+                              self.safe_project.safe_template.id, e.message)
         except Exception as e:
-            self.logger.error(f'Failed to update document template draft'
-                              f' {self.safe_project.safe_template.id}: {e}')
+            self.logger.error('Failed to update document template draft %s: %s',
+                              self.safe_project.safe_template.id, e)
 
-    async def _delete_file(self, filepath: pathlib.Path):
+    async def delete_file(self, filepath: pathlib.Path):
         if not filepath.is_file():
-            self.logger.debug(f'{filepath.as_posix()} is not a regular file - skipping')
+            self.logger.debug('%s is not a regular file - skipping',
+                              filepath.as_posix())
             return
         try:
             tfile = self.safe_project.get_template_file(filepath=filepath)
             if tfile is None:
-                # TODO: try to check if exists on remote (may not be synced yet)
-                self.logger.info(f'File {filepath.as_posix()} not tracked currently - skipping')
+                self.logger.info('File %s not tracked currently - skipping',
+                                 filepath.as_posix())
                 return
             await self._delete_template_file(tfile=tfile, project_update=True)
         except Exception as e:
-            self.logger.error(f'Failed to delete file {filepath.as_posix()}: {e}')
+            self.logger.error('Failed to delete file %s: %s',
+                              filepath.as_posix(), e)
 
-    async def _update_file(self, filepath: pathlib.Path):
+    async def update_file(self, filepath: pathlib.Path):
         if not filepath.is_file():
-            self.logger.debug(f'{filepath.as_posix()} is not a regular file - skipping')
+            self.logger.debug('%s is not a regular file - skipping',
+                              filepath.as_posix())
             return
         try:
             remote_tfile = self.safe_project.get_template_file(filepath=filepath)
@@ -443,30 +469,30 @@ class TDKCore:
             else:
                 await self._create_template_file(tfile=local_tfile, project_update=True)
         except Exception as e:
-            self.logger.error(f'Failed to update file {filepath.as_posix()}: {e}')
+            self.logger.error('Failed to update file %s: %s', filepath.as_posix(), e)
 
-    async def process_changes(self, changes: List[ChangeItem], force: bool):
+    async def process_changes(self, changes: list[ChangeItem], force: bool):
         self.changes_processor.clear()
         try:
             await self.changes_processor.process_changes(changes, force)
         except Exception as e:
-            self.logger.error(f'Failed to process changes: {e}')
+            self.logger.error('Failed to process changes: %s', e)
 
 
 class ChangesProcessor:
 
     def __init__(self, tdk: TDKCore):
-        self.tdk = tdk  # type: TDKCore
-        self.descriptor_change = None  # type: Optional[ChangeItem]
-        self.readme_change = None  # type: Optional[ChangeItem]
-        self.file_changes = []  # type: List[ChangeItem]
+        self.tdk: TDKCore = tdk
+        self.descriptor_change: ChangeItem | None = None
+        self.readme_change: ChangeItem | None = None
+        self.file_changes: list[ChangeItem] = []
 
     def clear(self):
         self.descriptor_change = None
         self.readme_change = None
         self.file_changes = []
 
-    def _split_changes(self, changes: List[ChangeItem]):
+    def _split_changes(self, changes: list[ChangeItem]):
         for change in changes:
             if change[1] == self.tdk.safe_project.descriptor_path:
                 self.descriptor_change = change
@@ -479,30 +505,32 @@ class ChangesProcessor:
         deleted = set()
         updated = set()
         for file_change in self.file_changes:
-            self.tdk.logger.debug(f'Processing: {_change(file_change, self.tdk.safe_project.template_dir)}')
+            self.tdk.logger.debug('Processing: %s',
+                                  _change(file_change, self.tdk.safe_project.template_dir))
             change_type = file_change[0]
             filepath = file_change[1]
             if change_type == watchfiles.Change.deleted and filepath not in deleted:
                 self.tdk.logger.debug('Scheduling delete operation')
                 deleted.add(filepath)
-                await self.tdk._delete_file(filepath)
+                await self.tdk.delete_file(filepath)
             elif filepath not in updated:
                 self.tdk.logger.debug('Scheduling update operation')
                 updated.add(filepath)
-                await self.tdk._update_file(filepath)
+                await self.tdk.update_file(filepath)
 
     async def _reload_descriptor(self, force: bool) -> bool:
         if self.descriptor_change is None:
             return False
         if self.descriptor_change[0] == watchfiles.Change.deleted:
-            raise RuntimeError(f'Deleted template descriptor {self.tdk.safe_project.descriptor_path} ... the end')
-        self.tdk.logger.debug(f'Reloading {TemplateProject.TEMPLATE_FILE} file')
+            raise RuntimeError(f'Deleted {self.tdk.safe_project.descriptor_path} ... the end')
+        self.tdk.logger.debug('Reloading %s file', TemplateProject.TEMPLATE_FILE)
         previous_id = self.tdk.safe_project.safe_template.id
         self.tdk.safe_project.load_descriptor()
         self.tdk.safe_project.load_readme()
         new_id = self.tdk.safe_project.safe_template.id
         if new_id != previous_id:
-            self.tdk.logger.warning(f'Template ID changed from {previous_id} to {new_id}')
+            self.tdk.logger.warning('Template ID changed from %s to %s',
+                                    previous_id, new_id)
             self.tdk.safe_project.load()
             await self.tdk.store_remote(force=force)
             self.tdk.logger.info('Template fully reloaded... waiting for new changes')
@@ -521,10 +549,10 @@ class ChangesProcessor:
     async def _update_descriptor(self):
         if self.readme_change is not None or self.descriptor_change is not None:
             self.tdk.logger.debug('Updating template descriptor (metadata)')
-            await self.tdk._update_descriptor()
+            await self.tdk.update_descriptor()
             self.tdk.safe_project.template = self.tdk.safe_template
 
-    async def process_changes(self, changes: List[ChangeItem], force: bool):
+    async def process_changes(self, changes: list[ChangeItem], force: bool):
         self._split_changes(changes)
         full_reload = await self._reload_descriptor(force)
         if not full_reload: