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

dsw/tdk/model.py

@@ -3,29 +3,30 @@ import json
 import logging
 import mimetypes
 import pathlib
-import pathspec  # type: ignore
 
 from collections import OrderedDict
-from typing import List, Dict, Optional, Tuple, Any
+from typing import Any
 
-from .consts import VERSION, DEFAULT_ENCODING, METAMODEL_VERSION, PATHSPEC_FACTORY
+import pathspec
+
+from .consts import VERSION, DEFAULT_ENCODING, METAMODEL_VERSION, PathspecFactory
 
 mimetypes.init()
 
 
 class TemplateFileType(enum.Enum):
-    asset = 'asset'
-    file = 'file'
+    ASSET = 'asset'
+    FILE = 'file'
 
 
 class PackageFilter:
 
-    def __init__(self, *, organization_id=None, km_id=None, min_version=None,
-                 max_version=None):
-        self.organization_id = organization_id  # type: Optional[str]
-        self.km_id = km_id  # type: Optional[str]
-        self.min_version = min_version  # type: Optional[str]
-        self.max_version = max_version  # type: Optional[str]
+    def __init__(self, *, organization_id: str | None = None, km_id: str | None = None,
+                 min_version: str | None = None, max_version: str | None = None):
+        self.organization_id = organization_id
+        self.km_id = km_id
+        self.min_version = min_version
+        self.max_version = max_version
 
     @classmethod
     def load(cls, data):
@@ -47,9 +48,10 @@ class PackageFilter:
 
 class Step:
 
-    def __init__(self, *, name=None, options=None):
-        self.name = name  # type: str
-        self.options = options or dict()  # type: Dict[str, str]
+    def __init__(self, *, name: str | None = None,
+                 options: dict[str, str] | None = None):
+        self.name = name
+        self.options = options or {}
 
     @classmethod
     def load(cls, data):
@@ -69,11 +71,12 @@ class Format:
 
     DEFAULT_ICON = 'fas fa-file'
 
-    def __init__(self, *, uuid=None, name=None, icon=None):
-        self.uuid = uuid  # type: str
-        self.name = name  # type: str
-        self.icon = icon or self.DEFAULT_ICON  # type: str
-        self.steps = []  # type: List[Step]
+    def __init__(self, *, uuid: str | None = None, name: str | None = None,
+                 icon: str | None = None):
+        self.uuid = uuid
+        self.name = name
+        self.icon: str = icon or self.DEFAULT_ICON
+        self.steps: list[Step] = []
 
     @classmethod
     def load(cls, data):
@@ -100,11 +103,12 @@ class TDKConfig:
     DEFAULT_README = 'README.md'
     DEFAULT_FILES = ['*']
 
-    def __init__(self, *, version=None, readme_file=None, files=None):
-        self.version = version or VERSION  # type: str
-        readme_file_str = readme_file or self.DEFAULT_README  # type: str
-        self.readme_file = pathlib.Path(readme_file_str)  # type: pathlib.Path
-        self.files = files or []  # type: List[str]
+    def __init__(self, *, version: str | None = None, readme_file: str | None = None,
+                 files: list[str] | None = None):
+        self.version: str = version or VERSION
+        readme_file_str: str = readme_file or self.DEFAULT_README
+        self.readme_file: pathlib.Path = pathlib.Path(readme_file_str)
+        self.files: list[str] = files or []
 
     @classmethod
     def load(cls, data):
@@ -127,19 +131,19 @@ class TemplateFile:
     DEFAULT_CONTENT_TYPE = 'application/octet-stream'
     TEMPLATE_EXTENSIONS = ('.j2', '.jinja', '.jinja2', '.jnj')
 
-    def __init__(self, *, remote_id=None, remote_type=None, filename=None,
-                 content_type=None, content=None):
-        self.remote_id = remote_id  # type: Optional[str]
-        self.filename = filename  # type: pathlib.Path
-        self.content = content  # type: bytes
-        self.content_type = content_type or self.guess_type()  # type: str
-        self.remote_type = remote_type or self.guess_tfile_type()  # type: TemplateFileType
+    def __init__(self, *, filename: pathlib.Path,
+                 remote_id: str | None = None, remote_type: TemplateFileType | None = None,
+                 content_type: str | None = None, content: bytes = b''):
+        self.remote_id = remote_id
+        self.filename = filename
+        self.content = content
+        self.content_type: str = content_type or self.guess_type()
+        self.remote_type: TemplateFileType = remote_type or self.guess_tfile_type()
 
     def guess_tfile_type(self):
-        return TemplateFileType.file if self.is_text else TemplateFileType.asset
+        return TemplateFileType.FILE if self.is_text else TemplateFileType.ASSET
 
     def guess_type(self) -> str:
-        # TODO: add own map of file extensions
         filename = self.filename.name
         for ext in self.TEMPLATE_EXTENSIONS:
             if filename.endswith(ext):
@@ -151,8 +155,7 @@ class TemplateFile:
 
     @property
     def is_text(self):
-        # TODO: custom mapping (also some starting with "application" are textual)
-        if getattr(self, 'remote_type', None) == TemplateFileType.file:
+        if getattr(self, 'remote_type', None) == TemplateFileType.FILE:
             return True
         return self.content_type.startswith('text')
 
@@ -163,6 +166,7 @@ class TemplateFile:
 
 class Template:
 
+    # pylint: disable-next=too-many-arguments
     def __init__(self, *, template_id=None, organization_id=None, version=None, name=None,
                  description=None, readme=None, template_license=None,
                  metamodel_version=None, tdk_config=None, loaded_json=None):
@@ -173,13 +177,13 @@ class Template:
         self.description = description  # type: str
         self.readme = readme  # type: str
         self.license = template_license  # type: str
-        self.metamodel_version = metamodel_version or METAMODEL_VERSION  # type: int
-        self.allowed_packages = []  # type: List[PackageFilter]
-        self.formats = []  # type: List[Format]
-        self.files = {}  # type: Dict[str, TemplateFile]
-        self.extras = []  # type: List[TemplateFile]
-        self.tdk_config = tdk_config or TDKConfig()  # type: TDKConfig
-        self.loaded_json = loaded_json or OrderedDict()  # type: OrderedDict
+        self.metamodel_version: int = metamodel_version or METAMODEL_VERSION
+        self.allowed_packages: list[PackageFilter] = []
+        self.formats: list[Format] = []
+        self.files: dict[str, TemplateFile] = {}
+        self.extras: list[TemplateFile] = []
+        self.tdk_config: TDKConfig = tdk_config or TDKConfig()
+        self.loaded_json: OrderedDict = loaded_json or OrderedDict()
 
     @property
     def id(self) -> str:
@@ -200,8 +204,8 @@ class Template:
                 org_id = data['organizationId']
                 tmp_id = data['templateId']
                 version = data['version']
-            except KeyError:
-                raise RuntimeError('Cannot retrieve template ID')
+            except KeyError as e:
+                raise RuntimeError('Cannot retrieve template ID') from e
         template = Template(
             template_id=tmp_id,
             organization_id=org_id,
@@ -244,7 +248,7 @@ class Template:
         self.loaded_json['_tdk'] = self.tdk_config.serialize()
         return self.loaded_json
 
-    def serialize_remote(self) -> Dict[str, Any]:
+    def serialize_remote(self) -> dict[str, Any]:
         return {
             'id': self.id,
             'templateId': self.template_id,
@@ -260,7 +264,7 @@ class Template:
             'phase': 'DraftDocumentTemplatePhase',
         }
 
-    def serialize_for_update(self) -> Dict[str, Any]:
+    def serialize_for_update(self) -> dict[str, Any]:
         return {
             'templateId': self.template_id,
             'version': self.version,
@@ -274,7 +278,7 @@ class Template:
             'phase': 'DraftDocumentTemplatePhase',
         }
 
-    def serialize_for_create(self, based_on: Optional[str] = None) -> Dict[str, Any]:
+    def serialize_for_create(self, based_on: str | None = None) -> dict[str, Any]:
         return {
             'basedOn': based_on,
             'name': self.name,
@@ -282,7 +286,7 @@ class Template:
             'version': self.version,
         }
 
-    def serialize_local_new(self) -> Dict[str, Any]:
+    def serialize_local_new(self) -> dict[str, Any]:
         return {
             'templateId': self.template_id,
             'organizationId': self.organization_id,
@@ -297,23 +301,24 @@ class Template:
         }
 
 
-def _to_ordered_dict(tuples: List[Tuple[str, Any]]) -> OrderedDict:
+def _to_ordered_dict(tuples: list[tuple[str, Any]]) -> OrderedDict:
     return OrderedDict(tuples)
 
 
 class TemplateProject:
 
     TEMPLATE_FILE = 'template.json'
-    DEFAULT_PATTERNS = ['!**/.git/**/*', '!template.json', '!template.zip']
+    DEFAULT_PATTERNS = ['!**/.*', '!**/.*/', '!**/~*', '!**/~*/',
+                        '!template.json', '!template.zip']
 
     json_decoder = json.JSONDecoder(object_pairs_hook=_to_ordered_dict)
 
-    def __init__(self, template_dir, logger):
-        self.template_dir = pathlib.Path(template_dir)  # type: pathlib.Path
+    def __init__(self, template_dir: pathlib.Path, logger: logging.Logger):
+        self.template_dir = pathlib.Path(template_dir)
         self.descriptor_path = self.template_dir / self.TEMPLATE_FILE
-        self.template = None  # type: Optional[Template]
-        self.used_readme = None  # type: Optional[pathlib.Path]
-        self._logger = logger  # type: logging.Logger
+        self.template: Template | None = None
+        self.used_readme: pathlib.Path | None = None
+        self._logger = logger
 
     @property
     def logger(self) -> logging.Logger:
@@ -331,8 +336,8 @@ class TemplateProject:
         try:
             content = self.descriptor_path.read_text(encoding=DEFAULT_ENCODING)
             self.template = Template.load_local(self.json_decoder.decode(content))
-        except Exception:
-            raise RuntimeError(f'Unable to load template using {self.descriptor_path}.')
+        except Exception as e:
+            raise RuntimeError(f'Unable to load template using {self.descriptor_path}.') from e
 
     def load_readme(self):
         readme = self.safe_template.tdk_config.readme_file
@@ -341,7 +346,7 @@ class TemplateProject:
                 self.used_readme = self.template_dir / readme
                 self.safe_template.readme = self.used_readme.read_text(encoding=DEFAULT_ENCODING)
             except Exception as e:
-                raise RuntimeWarning(f'README file "{readme}" cannot be loaded: {e}')
+                raise RuntimeWarning(f'README file "{readme}" cannot be loaded: {e}') from e
 
     def load_file(self, filepath: pathlib.Path) -> TemplateFile:
         try:
@@ -353,7 +358,7 @@ class TemplateProject:
             self.safe_template.files[filepath.as_posix()] = tfile
             return tfile
         except Exception as e:
-            raise RuntimeWarning(f'Failed to load template file {filepath}: {e}')
+            raise RuntimeWarning(f'Failed to load template file {filepath}: {e}') from e
 
     def load_files(self):
         self.safe_template.files.clear()
@@ -362,22 +367,24 @@ class TemplateProject:
 
     @property
     def files_pathspec(self) -> pathspec.PathSpec:
-        # TODO: make this more efficient (reload only when tdk_config changes, otherwise cache)
         patterns = self.safe_template.tdk_config.files + self.DEFAULT_PATTERNS
-        return pathspec.PathSpec.from_lines(PATHSPEC_FACTORY, patterns)
+        return pathspec.PathSpec.from_lines(PathspecFactory, patterns)
 
-    def list_files(self) -> List[pathlib.Path]:
-        files = (pathlib.Path(p) for p in self.files_pathspec.match_tree_files(str(self.template_dir)))
+    def list_files(self) -> list[pathlib.Path]:
+        files = (pathlib.Path(p)
+                 for p in self.files_pathspec.match_tree_files(str(self.template_dir)))
         if self.used_readme is not None:
             return list(p for p in files if p != self.used_readme.relative_to(self.template_dir))
         return list(files)
 
-    def _relative_paths_eq(self, filepath1: Optional[pathlib.Path], filepath2: Optional[pathlib.Path]) -> bool:
+    def _relative_paths_eq(self, filepath1: pathlib.Path | None,
+                           filepath2: pathlib.Path | None) -> bool:
         if filepath1 is None or filepath2 is None:
             return False
         return filepath1.relative_to(self.template_dir) == filepath2.relative_to(self.template_dir)
 
-    def is_template_file(self, filepath: pathlib.Path, include_descriptor: bool = False, include_readme: bool = False):
+    def is_template_file(self, filepath: pathlib.Path, include_descriptor: bool = False,
+                         include_readme: bool = False):
         if include_readme and self._relative_paths_eq(filepath, self.used_readme):
             return True
         if include_descriptor and self._relative_paths_eq(filepath, self.descriptor_path):
@@ -400,7 +407,7 @@ class TemplateProject:
         filename = tfile.filename.as_posix()
         self.safe_template.files[filename] = tfile
 
-    def get_template_file(self, filepath: pathlib.Path) -> Optional[TemplateFile]:
+    def get_template_file(self, filepath: pathlib.Path) -> TemplateFile | None:
         if filepath.is_absolute():
             filepath = filepath.relative_to(self.template_dir)
         return self.safe_template.files.get(filepath.as_posix(), None)
@@ -419,7 +426,10 @@ class TemplateProject:
     def store_descriptor(self, force: bool):
         self._write_file(
             filepath=self.descriptor_path,
-            contents=json.dumps(self.safe_template.serialize_local(), indent=4).encode(encoding=DEFAULT_ENCODING),
+            contents=json.dumps(
+                obj=self.safe_template.serialize_local(),
+                indent=4
+            ).encode(encoding=DEFAULT_ENCODING),
             force=force,
         )
 

dsw/tdk/templates/starter.j2

@@ -1,7 +1,6 @@
 {%- raw -%}
 {# This is the template starter file generated by DSW TDK #}
-{%- set km = ctx.knowledgeModel -%}
-{%- set repliesMap = ctx.questionnaireReplies -%}
+{%- set dc = ctx|to_context_obj -%}
 
 {#
 ##

dsw/tdk/utils.py

@@ -1,8 +1,7 @@
-import jinja2  # type: ignore
 import pathlib
 import uuid
 
-from typing import List, Set, Optional
+import jinja2
 
 from .consts import DEFAULT_ENCODING, DEFAULT_README
 from .model import Template, TemplateFile, Format, Step, PackageFilter
@@ -20,10 +19,10 @@ j2_env = jinja2.Environment(
 
 class UUIDGen:
 
-    _uuids = set()  # type: Set[uuid.UUID]
+    _uuids: set[uuid.UUID] = set()
 
     @classmethod
-    def used(cls) -> Set[uuid.UUID]:
+    def used(cls) -> set[uuid.UUID]:
         return cls._uuids
 
     @classmethod
@@ -91,10 +90,10 @@ class TemplateBuilder:
 
     def __init__(self):
         self.template = Template()
-        self._formats = []  # type: List[FormatSpec]
+        self._formats: list[FormatSpec] = []
 
     @property
-    def formats(self) -> List[FormatSpec]:
+    def formats(self) -> list[FormatSpec]:
         return self._formats
 
     def _validate_field(self, field_name: str):
@@ -177,13 +176,13 @@ class TemplateBuilder:
         license_file = j2_env.get_template('LICENSE.j2').render(template=self.template)
         self.template.tdk_config.files.append('LICENSE')
         self.template.files['LICENSE'] = TemplateFile(
-            filename='LICENSE',
+            filename=pathlib.Path('LICENSE'),
             content_type='text/plain',
             content=license_file.encode(encoding=DEFAULT_ENCODING),
         )
 
         self.template.files['.env'] = TemplateFile(
-            filename='.env',
+            filename=pathlib.Path('.env'),
             content_type='text/plain',
             content=create_dot_env().encode(encoding=DEFAULT_ENCODING),
         )
@@ -191,7 +190,7 @@ class TemplateBuilder:
         return self.template
 
 
-def create_dot_env(api_url: Optional[str] = None, api_key: Optional[str] = None) -> str:
+def create_dot_env(api_url: str | None = None, api_key: str | None = None) -> str:
     return j2_env.get_template('env.j2').render(api_url=api_url, api_key=api_key)
 
 

dsw/tdk/validation.py

@@ -15,55 +15,82 @@ class ValidationError(BaseException):
 
 def _validate_required(field_name: str, value) -> List[ValidationError]:
     if value is None:
-        return [ValidationError(field_name, 'Missing but it is required')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Missing but it is required',
+        )]
     return []
 
 
 def _validate_non_empty(field_name: str, value) -> List[ValidationError]:
     if value is not None and len(value.strip()) == 0:
-        return [ValidationError(field_name, 'Cannot be empty or only-whitespace')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Cannot be empty or only-whitespace',
+        )]
     return []
 
 
 def _validate_content_type(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_MIME_TYPE, value) is None:
-        return [ValidationError(field_name, 'Content type should be valid IANA media type')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Content type should be valid IANA media type',
+        )]
     return []
 
 
 def _validate_extension(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_ORGANIZATION_ID, value) is None:
-        return [ValidationError(field_name, 'File extension should contain only letters, numbers and dots (inside-only)')]
+        return [ValidationError(
+            field_name=field_name,
+            message='File extension should contain only letters, numbers and dots (inside-only)',
+        )]
     return []
 
 
 def _validate_organization_id(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_ORGANIZATION_ID, value) is None:
-        return [ValidationError(field_name, 'Organization ID may contain only letters, numbers, and period (inside-only)')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Organization ID may contain only letters, numbers, and period (inside-only)',
+        )]
     return []
 
 
 def _validate_template_id(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_TEMPLATE_ID, value) is None:
-        return [ValidationError(field_name, 'Template ID may contain only letters, numbers, and dash (inside-only)')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Template ID may contain only letters, numbers, and dash (inside-only)',
+        )]
     return []
 
 
 def _validate_km_id(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_KM_ID, value) is None:
-        return [ValidationError(field_name, 'KM ID may contain only letters, numbers, and dash (inside-only)')]
+        return [ValidationError(
+            field_name=field_name,
+            message='KM ID may contain only letters, numbers, and dash (inside-only)',
+        )]
     return []
 
 
 def _validate_version(field_name: str, value) -> List[ValidationError]:
     if value is not None and re.match(REGEX_SEMVER, value) is None:
-        return [ValidationError(field_name, 'Version must be in semver format <NUM>.<NUM>.<NUM>')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Version must be in semver format <NUM>.<NUM>.<NUM>',
+        )]
     return []
 
 
 def _validate_natural(field_name: str, value) -> List[ValidationError]:
     if value is not None and (not isinstance(value, int) or value < 1):
-        return [ValidationError(field_name, 'It must be positive integer')]
+        return [ValidationError(
+            field_name=field_name,
+            message='It must be positive integer',
+        )]
     return []
 
 
@@ -72,16 +99,31 @@ def _validate_package_id(field_name: str, value: str) -> List[ValidationError]:
     if value is None:
         return res
     if not isinstance(value, str):
-        return [ValidationError(field_name, 'Package ID is not a string')]
+        return [ValidationError(
+            field_name=field_name,
+            message='Package ID is not a string',
+        )]
     parts = value.split(':')
     if len(parts) != 3:
-        res.append(ValidationError(field_name, 'Package ID is not valid (only {len(parts)} parts)'))
+        res.append(ValidationError(
+            field_name=field_name,
+            message='Package ID is not valid (only {len(parts)} parts)',
+        ))
     if re.match(REGEX_ORGANIZATION_ID, parts[0]) is None:
-        res.append(ValidationError(field_name, 'Package ID contains invalid organization id'))
+        res.append(ValidationError(
+            field_name=field_name,
+            message='Package ID contains invalid organization id',
+        ))
     if re.match(REGEX_KM_ID, parts[1]) is None:
-        res.append(ValidationError(field_name, 'Package ID contains invalid KM id'))
+        res.append(ValidationError(
+            field_name=field_name,
+            message='Package ID contains invalid KM id',
+        ))
     if re.match(REGEX_SEMVER, parts[2]) is None:
-        res.append(ValidationError(field_name, 'Package ID contains invalid version'))
+        res.append(ValidationError(
+            field_name=field_name,
+            message='Package ID contains invalid version',
+        ))
     return res
 
 
@@ -91,11 +133,20 @@ def _validate_jinja_options(field_name: str, value: Dict[str, str]) -> List[Vali
         return res
     for k in ('template', 'content-type', 'extension'):
         if k not in value.keys():
-            res.append(ValidationError(field_name, 'Jinja option cannot be left out'))
+            res.append(ValidationError(
+                field_name=field_name,
+                message='Jinja option cannot be left out',
+            ))
         elif value[k] is None or not isinstance(value[k], str) or len(value[k]) == 0:
-            res.append(ValidationError(field_name, 'Jinja option cannot be empty'))
+            res.append(ValidationError(
+                field_name=field_name,
+                message='Jinja option cannot be empty',
+            ))
     if 'content-type' in value.keys():
-        res.extend(_validate_content_type(f'{field_name}.content-type', value['content-type']))
+        res.extend(_validate_content_type(
+            field_name=f'{field_name}.content-type',
+            value=value['content-type'],
+        ))
     return res
 
 
@@ -129,7 +180,10 @@ class GenericValidator:
             if field_name.startswith('__'):
                 continue
             for validator in validators:
-                result.extend(validator(field_name_prefix + field_name, getattr(entity, field_name)))
+                result.extend(validator(
+                    field_name=f'{field_name_prefix}{field_name}',
+                    value=getattr(entity, field_name),
+                ))
         if '__all' in self.rules.keys():
             result.extend(self.rules['__all'](field_name_prefix, entity))
         return result

{dsw_tdk-4.12.0.dist-info → dsw_tdk-4.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dsw-tdk
-Version: 4.12.0
+Version: 4.14.0
 Summary: Data Stewardship Wizard Template Development Toolkit
 Author-email: Marek Suchánek <marek.suchanek@ds-wizard.org>
 License: Apache License 2.0
@@ -12,12 +12,12 @@ Classifier: Framework :: AsyncIO
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Utilities
-Requires-Python: <4,>=3.9
+Requires-Python: <4,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp

dsw_tdk-4.14.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+dsw/tdk/__init__.py,sha256=zJeTybb0SqiNdGLkANjRa36hku4axi17mZL2dM3tHto,288
+dsw/tdk/__main__.py,sha256=cCzxo6f7raF50kQE-nM_segNjCNe723ZrxOBB6f3qwc,84
+dsw/tdk/api_client.py,sha256=1WpUSgi8BfNrq3rUHWSfcZnmNGydID1mzkWBp5TnNmc,14727
+dsw/tdk/build_info.py,sha256=xBZ1XqKVizhNtN7VHteBe1AGMyK4GwZrZQtrNx-EZz8,381
+dsw/tdk/cli.py,sha256=7OYoGvceSd2TuyeRXFv7ikylJNKFk3Ua8t9l_Vas12E,22012
+dsw/tdk/consts.py,sha256=WwGlNfUF50WmQZQwyRDRPufOAXwwABjJuF2lkTU9VMM,619
+dsw/tdk/core.py,sha256=LvpB8J_AmAe-ljEIYjO3oP45EDAgjzKGEnZkkDqNiho,26448
+dsw/tdk/model.py,sha256=5_qSOEdEeikskvoThClPQU2szS3pDw8-R2kDQVdBf7U,17151
+dsw/tdk/utils.py,sha256=ICZpgxkDRWg9lq1gnHyQCEISFMtmGtu8Hl5yEclwn14,5685
+dsw/tdk/validation.py,sha256=6GTyBpSvrvj73A2RkFJ-NL7SCjXFI4JnPneAEumR-ww,8847
+dsw/tdk/templates/LICENSE.j2,sha256=6WzK06169rxZ4V_boYgejcZkw-1Up_WoU18iI3Gbkfs,60
+dsw/tdk/templates/README.md.j2,sha256=FzUABeMM8To0oT48Kytoox64uAZ8F7FSAAXgpyKzqdU,247
+dsw/tdk/templates/env.j2,sha256=7IJ6HAIY1bXKLake4c72DSEUcQtAquO5wlSgH8vg_8s,97
+dsw/tdk/templates/starter.j2,sha256=JKJIkiXsmBO4P6pKXM4IvSz3JgJhqCnaZI1NVfPPnXg,246
+dsw_tdk-4.14.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dsw_tdk-4.14.0.dist-info/METADATA,sha256=1CXbl6itGPeaQ2wm-GTEzEg52J6J602oJG0pi_rnBIk,6022
+dsw_tdk-4.14.0.dist-info/WHEEL,sha256=M1ikteR9eetPNvm1LyQ3rpXxNYuGd90oakQO1a-ohSk,109
+dsw_tdk-4.14.0.dist-info/entry_points.txt,sha256=lwD5ZzRCbTFSjP1-SkhYsaJe8sEXOWWgMAMUhw0v2Hk,41
+dsw_tdk-4.14.0.dist-info/top_level.txt,sha256=7SfbsHFoJ_vlAgG6C-xzETETwYO71dBrGnod8uMFnjw,4
+dsw_tdk-4.14.0.dist-info/RECORD,,

{dsw_tdk-4.12.0.dist-info → dsw_tdk-4.14.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

dsw_tdk-4.12.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-dsw/tdk/__init__.py,sha256=zJeTybb0SqiNdGLkANjRa36hku4axi17mZL2dM3tHto,288
-dsw/tdk/__main__.py,sha256=IkqeOatxravhcQCdk4l0BkbaMILkgVopB9phYCIR1uo,38
-dsw/tdk/api_client.py,sha256=N3-PoO__kPtqFmR2QY-OG-9OkjYZwuXg8JxcBgpI8vQ,14222
-dsw/tdk/build_info.py,sha256=tppWzn16SBK4k6X9Kb1tcx2_lK7t2IXi0_N9QmbdW1s,381
-dsw/tdk/cli.py,sha256=_DZRSAo04wajiWVTod6lPdh477Rdxf7zBomySPxiL1c,21676
-dsw/tdk/consts.py,sha256=40HjoDQ4bX5X4G9JYhZ7jPbWI6Xj6NBCeXMTWJPENmQ,635
-dsw/tdk/core.py,sha256=Tyv2KXgBlm9mbJqFMaeyn6-07JE1nPHbKWTIKAvu2XY,25970
-dsw/tdk/model.py,sha256=B9_cCmg_Z2IHabMMychKFV4dh4SFPVEentuPcb5fzlY,17235
-dsw/tdk/utils.py,sha256=gW_-1qj7osHgKhTjjMGeVL2pxoBDQuq7VjRE6OmEMCw,5734
-dsw/tdk/validation.py,sha256=hr04MRVqwBIBeKoX6v53Ix1S-vjvIQYM5dwI0SnMRsc,7827
-dsw/tdk/templates/LICENSE.j2,sha256=6WzK06169rxZ4V_boYgejcZkw-1Up_WoU18iI3Gbkfs,60
-dsw/tdk/templates/README.md.j2,sha256=FzUABeMM8To0oT48Kytoox64uAZ8F7FSAAXgpyKzqdU,247
-dsw/tdk/templates/env.j2,sha256=7IJ6HAIY1bXKLake4c72DSEUcQtAquO5wlSgH8vg_8s,97
-dsw/tdk/templates/starter.j2,sha256=XjZy3T9i8aWFlq4clXL6Q4JNh455crGelR9AoHisTbw,296
-dsw_tdk-4.12.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dsw_tdk-4.12.0.dist-info/METADATA,sha256=ldEae9hLRn_sVciIFiUTULYaCeqpoSaqsp6ElbqvoCQ,6020
-dsw_tdk-4.12.0.dist-info/WHEEL,sha256=OpXWERl2xLPRHTvd2ZXo_iluPEQd8uSbYkJ53NAER_Y,109
-dsw_tdk-4.12.0.dist-info/entry_points.txt,sha256=lwD5ZzRCbTFSjP1-SkhYsaJe8sEXOWWgMAMUhw0v2Hk,41
-dsw_tdk-4.12.0.dist-info/top_level.txt,sha256=7SfbsHFoJ_vlAgG6C-xzETETwYO71dBrGnod8uMFnjw,4
-dsw_tdk-4.12.0.dist-info/RECORD,,