diff --git a/src/cpl_cli/.cpl/schematic_configmodel.py b/src/cpl_cli/.cpl/schematic_configmodel.py index 18a01d37..f03978a3 100644 --- a/src/cpl_cli/.cpl/schematic_configmodel.py +++ b/src/cpl_cli/.cpl/schematic_configmodel.py @@ -17,21 +17,15 @@ class ConfigModel(GenerateSchematicABC): class $Name(ConfigurationModelABC): - def __init__(self): + def __init__(self, atr: str = None): ConfigurationModelABC.__init__(self) - self._atr = '' + self._atr = atr @property def atr(self) -> str: return self._atr - def from_dict(self, settings: dict): - try: - self._atr = settings['atr'] - except Exception as e: - Console.error(f'[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings') - Console.error(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}') """ x = self.build_code_str(code, Name=self._class_name) return x diff --git a/src/cpl_cli/cli_settings.py b/src/cpl_cli/cli_settings.py index c23dfb8d..3215c91c 100644 --- a/src/cpl_cli/cli_settings.py +++ b/src/cpl_cli/cli_settings.py @@ -7,18 +7,11 @@ from cpl_cli.cli_settings_name_enum import CLISettingsNameEnum class CLISettings(ConfigurationModelABC): - def __init__(self): + def __init__(self, pip_path: str = None): ConfigurationModelABC.__init__(self) - self._pip_path: Optional[str] = None + self._pip_path: Optional[str] = pip_path @property def pip_path(self) -> str: return self._pip_path - - def from_dict(self, settings: dict): - try: - self._pip_path = settings[CLISettingsNameEnum.pip_path.value] - except Exception as e: - Console.error(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - Console.error(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") diff --git a/src/cpl_cli/configuration/build_settings.py b/src/cpl_cli/configuration/build_settings.py index 027f4e15..d493810a 100644 --- a/src/cpl_cli/configuration/build_settings.py +++ b/src/cpl_cli/configuration/build_settings.py @@ -2,27 +2,57 @@ import sys import traceback from typing import Optional +from cpl_cli.configuration.build_settings_name_enum import BuildSettingsNameEnum +from cpl_cli.configuration.project_type_enum import ProjectTypeEnum from cpl_core.configuration.configuration_model_abc import ConfigurationModelABC from cpl_core.console.console import Console from cpl_core.console.foreground_color_enum import ForegroundColorEnum -from cpl_cli.configuration.build_settings_name_enum import BuildSettingsNameEnum -from cpl_cli.configuration.project_type_enum import ProjectTypeEnum class BuildSettings(ConfigurationModelABC): - def __init__(self): + def __init__( + self, + project_type: ProjectTypeEnum = None, + source_path: str = None, + output_path: str = None, + main: str = None, + entry_point: str = None, + include_package_data: bool = None, + included: list[str] = None, + excluded: list[str] = None, + package_data: dict[str, list[str]] = None, + project_references: list[str] = None, + ): ConfigurationModelABC.__init__(self) - self._project_type: Optional[ProjectTypeEnum] = None - self._source_path: Optional[str] = None - self._output_path: Optional[str] = None - self._main: Optional[str] = None - self._entry_point: Optional[str] = None - self._include_package_data: Optional[bool] = None - self._included: Optional[list[str]] = None - self._excluded: Optional[list[str]] = None - self._package_data: Optional[dict[str, list[str]]] = None - self._project_references: Optional[list[str]] = None + self._project_type: Optional[ProjectTypeEnum] = project_type + self._source_path: Optional[str] = source_path + self._output_path: Optional[str] = output_path + self._main: Optional[str] = main + self._entry_point: Optional[str] = entry_point + self._include_package_data: Optional[bool] = include_package_data + self._included: Optional[list[str]] = included + self._excluded: Optional[list[str]] = excluded + self._package_data: Optional[dict[str, list[str]]] = package_data + self._project_references: Optional[list[str]] = [] if project_references is None else project_references + + if sys.platform == "win32": + self._source_path = str(self._source_path).replace("/", "\\") + self._output_path = str(self._output_path).replace("/", "\\") + + # windows paths for excluded files + excluded = [] + for ex in self._excluded: + excluded.append(str(ex).replace("/", "\\")) + + self._excluded = excluded + + # windows paths for included files + included = [] + for inc in self._included: + included.append(str(inc).replace("/", "\\")) + + self._included = included @property def project_type(self): diff --git a/src/cpl_cli/configuration/project_settings.py b/src/cpl_cli/configuration/project_settings.py index 1b99af6e..16a6dcbc 100644 --- a/src/cpl_cli/configuration/project_settings.py +++ b/src/cpl_cli/configuration/project_settings.py @@ -12,26 +12,59 @@ from cpl_core.console.foreground_color_enum import ForegroundColorEnum class ProjectSettings(ConfigurationModelABC): - def __init__(self): + def __init__( + self, + name: str = None, + version: VersionSettings = None, + author: str = None, + author_email: str = None, + description: str = None, + long_description: str = None, + url: str = None, + copyright_date: str = None, + copyright_name: str = None, + license_name: str = None, + license_description: str = None, + dependencies: list = None, + dev_dependencies: list = None, + python_version: str = None, + python_path: dict = None, + python_executable: str = None, + classifiers: list = None, + ): ConfigurationModelABC.__init__(self) - self._name: Optional[str] = None - self._version: Optional[VersionSettings] = VersionSettings() - self._author: Optional[str] = None - self._author_email: Optional[str] = None - self._description: Optional[str] = None - self._long_description: Optional[str] = None - self._url: Optional[str] = None - self._copyright_date: Optional[str] = None - self._copyright_name: Optional[str] = None - self._license_name: Optional[str] = None - self._license_description: Optional[str] = None - self._dependencies: Optional[list[str]] = None - self._dev_dependencies: Optional[list[str]] = None - self._python_version: Optional[str] = None - self._python_path: Optional[str] = None - self._python_executable: Optional[str] = None - self._classifiers: Optional[list[str]] = None + self._name: Optional[str] = name + self._version: Optional[VersionSettings] = version + self._author: Optional[str] = author + self._author_email: Optional[str] = author_email + self._description: Optional[str] = description + self._long_description: Optional[str] = long_description + self._url: Optional[str] = url + self._copyright_date: Optional[str] = copyright_date + self._copyright_name: Optional[str] = copyright_name + self._license_name: Optional[str] = license_name + self._license_description: Optional[str] = license_description + self._dependencies: Optional[list[str]] = [] if dependencies is None else dependencies + self._dev_dependencies: Optional[list[str]] = [] if dev_dependencies is None else dev_dependencies + self._python_version: Optional[str] = python_version + self._python_path: Optional[str] = python_path + self._python_executable: Optional[str] = python_executable + self._classifiers: Optional[list[str]] = [] if classifiers is None else classifiers + + if python_path is not None: + path = f"{python_path[sys.platform]}" + + if path == "" or path is None: + Error.warn(f"{ProjectSettingsNameEnum.python_path.value} not set") + path = sys.executable + else: + if not path.endswith("bin/python"): + path = os.path.join(path, "bin/python") + else: + path = sys.executable + + self._python_executable = path @property def name(self): diff --git a/src/cpl_cli/configuration/version_settings.py b/src/cpl_cli/configuration/version_settings.py index c1439673..2e067a64 100644 --- a/src/cpl_cli/configuration/version_settings.py +++ b/src/cpl_cli/configuration/version_settings.py @@ -10,7 +10,7 @@ class VersionSettings(ConfigurationModelABC): self._major: Optional[str] = major self._minor: Optional[str] = minor - self._micro: Optional[str] = micro + self._micro: Optional[str] = micro if micro != "" else None @property def major(self) -> str: @@ -30,13 +30,6 @@ class VersionSettings(ConfigurationModelABC): else: return f"{self._major}.{self._minor}.{self._micro}" - def from_dict(self, settings: dict): - self._major = settings[VersionSettingsNameEnum.major.value] - self._minor = settings[VersionSettingsNameEnum.minor.value] - micro = settings[VersionSettingsNameEnum.micro.value] - if micro != "": - self._micro = micro - def to_dict(self) -> dict: version = { VersionSettingsNameEnum.major.value: self._major, diff --git a/src/cpl_cli/configuration/workspace_settings.py b/src/cpl_cli/configuration/workspace_settings.py index 10ba93ac..08c4f3fb 100644 --- a/src/cpl_cli/configuration/workspace_settings.py +++ b/src/cpl_cli/configuration/workspace_settings.py @@ -1,18 +1,23 @@ import traceback from typing import Optional +from cpl_cli.configuration.workspace_settings_name_enum import WorkspaceSettingsNameEnum from cpl_core.configuration.configuration_model_abc import ConfigurationModelABC from cpl_core.console import Console -from cpl_cli.configuration.workspace_settings_name_enum import WorkspaceSettingsNameEnum class WorkspaceSettings(ConfigurationModelABC): - def __init__(self): + def __init__( + self, + default_project: str = None, + projects: dict = None, + scripts: dict = None, + ): ConfigurationModelABC.__init__(self) - self._default_project: Optional[str] = None - self._projects: dict[str, str] = {} - self._scripts: dict[str, str] = {} + self._default_project: Optional[str] = default_project + self._projects: dict[str, str] = {} if projects is None else projects + self._scripts: dict[str, str] = {} if scripts is None else scripts @property def default_project(self) -> str: @@ -25,16 +30,3 @@ class WorkspaceSettings(ConfigurationModelABC): @property def scripts(self): return self._scripts - - def from_dict(self, settings: dict): - try: - self._default_project = settings[WorkspaceSettingsNameEnum.default_project.value] - self._projects = settings[WorkspaceSettingsNameEnum.projects.value] - - if WorkspaceSettingsNameEnum.scripts.value in settings: - self._scripts = settings[WorkspaceSettingsNameEnum.scripts.value] - else: - self._scripts = {} - except Exception as e: - Console.error(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - Console.error(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") diff --git a/src/cpl_core/configuration/configuration.py b/src/cpl_core/configuration/configuration.py index 7e179274..1fa6a3d3 100644 --- a/src/cpl_core/configuration/configuration.py +++ b/src/cpl_core/configuration/configuration.py @@ -290,6 +290,7 @@ class Configuration(ConfigurationABC): Console.color_reset() configuration.from_dict(value) else: + Console.error(sub, 1) configuration = JSONProcessor.process(sub, value) self.add_configuration(sub, configuration) diff --git a/src/cpl_core/database/database_settings.py b/src/cpl_core/database/database_settings.py index 7ca4ba19..609a3075 100644 --- a/src/cpl_core/database/database_settings.py +++ b/src/cpl_core/database/database_settings.py @@ -65,36 +65,3 @@ class DatabaseSettings(ConfigurationModelABC): @property def auth_plugin(self) -> Optional[str]: return self._auth_plugin - - # def from_dict(self, settings: dict): - # r"""Sets attributes from given dict - # - # Parameter: - # settings: :class:`dict` - # """ - # try: - # self._host = settings[DatabaseSettingsNameEnum.host.value] - # if DatabaseSettingsNameEnum.port.value in settings: - # self._port = settings[DatabaseSettingsNameEnum.port.value] - # else: - # self._port = 3306 - # self._user = settings[DatabaseSettingsNameEnum.user.value] - # self._password = settings[DatabaseSettingsNameEnum.password.value] - # self._databse = settings[DatabaseSettingsNameEnum.database.value] - # - # if DatabaseSettingsNameEnum.charset.value in settings: - # self._charset = settings[DatabaseSettingsNameEnum.charset.value] - # - # if DatabaseSettingsNameEnum.buffered.value in settings: - # self._use_unicode = bool(settings[DatabaseSettingsNameEnum.use_unicode.value]) - # - # if DatabaseSettingsNameEnum.buffered.value in settings: - # self._buffered = bool(settings[DatabaseSettingsNameEnum.buffered.value]) - # - # if DatabaseSettingsNameEnum.auth_plugin.value in settings: - # self._auth_plugin = settings[DatabaseSettingsNameEnum.auth_plugin.value] - # except Exception as e: - # Console.set_foreground_color(ForegroundColorEnum.red) - # Console.write_line(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - # Console.write_line(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") - # Console.set_foreground_color(ForegroundColorEnum.default) diff --git a/src/cpl_core/logging/logging_settings.py b/src/cpl_core/logging/logging_settings.py index 41f31277..1150b9ec 100644 --- a/src/cpl_core/logging/logging_settings.py +++ b/src/cpl_core/logging/logging_settings.py @@ -55,15 +55,3 @@ class LoggingSettings(ConfigurationModelABC): @level.setter def level(self, level: LoggingLevelEnum) -> None: self._level = level - - # def from_dict(self, settings: dict): - # try: - # self._path = settings[LoggingSettingsNameEnum.path.value] - # self._filename = settings[LoggingSettingsNameEnum.filename.value] - # self._console = LoggingLevelEnum[settings[LoggingSettingsNameEnum.console_level.value]] - # self._level = LoggingLevelEnum[settings[LoggingSettingsNameEnum.file_level.value]] - # except Exception as e: - # Console.set_foreground_color(ForegroundColorEnum.red) - # Console.write_line(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - # Console.write_line(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") - # Console.set_foreground_color(ForegroundColorEnum.default) diff --git a/src/cpl_core/mailing/email_client_settings.py b/src/cpl_core/mailing/email_client_settings.py index 4bcaca8a..bac1b98f 100644 --- a/src/cpl_core/mailing/email_client_settings.py +++ b/src/cpl_core/mailing/email_client_settings.py @@ -49,13 +49,3 @@ class EMailClientSettings(ConfigurationModelABC): @credentials.setter def credentials(self, credentials: str) -> None: self._credentials = credentials - - # def from_dict(self, settings: dict): - # try: - # self._host = settings[EMailClientSettingsNameEnum.host.value] - # self._port = settings[EMailClientSettingsNameEnum.port.value] - # self._user_name = settings[EMailClientSettingsNameEnum.user_name.value] - # self._credentials = settings[EMailClientSettingsNameEnum.credentials.value] - # except Exception as e: - # Console.error(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - # Console.error(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") diff --git a/src/cpl_core/time/time_format_settings.py b/src/cpl_core/time/time_format_settings.py index bcc7ec4f..536ecae6 100644 --- a/src/cpl_core/time/time_format_settings.py +++ b/src/cpl_core/time/time_format_settings.py @@ -54,15 +54,3 @@ class TimeFormatSettings(ConfigurationModelABC): @date_time_log_format.setter def date_time_log_format(self, date_time_now_format: str) -> None: self._date_time_log_format = date_time_now_format - - # def from_dict(self, settings: dict): - # try: - # self._date_format = settings[TimeFormatSettingsNamesEnum.date_format.value] - # self._time_format = settings[TimeFormatSettingsNamesEnum.time_format.value] - # self._date_time_format = settings[TimeFormatSettingsNamesEnum.date_time_format.value] - # self._date_time_log_format = settings[TimeFormatSettingsNamesEnum.date_time_log_format.value] - # except Exception as e: - # Console.set_foreground_color(ForegroundColorEnum.red) - # Console.write_line(f"[ ERROR ] [ {__name__} ]: Reading error in {type(self).__name__} settings") - # Console.write_line(f"[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}") - # Console.set_foreground_color(ForegroundColorEnum.default) diff --git a/src/cpl_core/utils/json_processor.py b/src/cpl_core/utils/json_processor.py index e28176f8..1f296079 100644 --- a/src/cpl_core/utils/json_processor.py +++ b/src/cpl_core/utils/json_processor.py @@ -24,8 +24,8 @@ class JSONProcessor: else: value = values[name_first_lower] - if isinstance(value, dict): - value = JSONProcessor.process(parameter.annotation, value) + if isinstance(value, dict) and not issubclass(parameter.annotation, dict): + value = JSONProcessor.process(dict, value) if issubclass(parameter.annotation, enum.Enum): value = parameter.annotation[value]