use protected and private properties

src/zrb/helper/env_map/fetch.py

@@ -42,7 +42,7 @@ def _add_envs_to_env_map(
     env_map: Mapping[str, str], envs: List[Env]
 ) -> Mapping[str, str]:
     for env in envs:
-        if env.os_name == '':
+        if env.get_os_name() == '':
             continue
         env_name = _get_env_name(env)
         env_default = _get_env_default(env)
@@ -64,13 +64,13 @@ def _cascade_env_map(
 
 @typechecked
 def _get_env_name(env: Env) -> str:
-    if env.os_name is None:
-        return env.name
-    return env.os_name
+    if env.get_os_name() is None:
+        return env.get_name()
+    return env.get_os_name()
 
 
 @typechecked
 def _get_env_default(env: Env) -> str:
-    if is_probably_jinja(env.default):
+    if is_probably_jinja(env.get_default()):
         return ''
-    return env.default
+    return env.get_default()

src/zrb/task/base_task/component/common_task_model.py

@@ -221,9 +221,9 @@ def _get_combined_env(self) -> Mapping[str, Env]:
             )
         for env_file in self._get_env_files():
             for env in env_file.get_envs():
-                all_envs[env.name] = env
+                all_envs[env.get_name()] = env
         for env in self._get_envs():
-            all_envs[env.name] = env
+            all_envs[env.get_name()] = env
         self.__allow_add_envs = False
         self.__allow_add_env_files = False
         return all_envs

src/zrb/task/docker_compose_task.py

@@ -213,7 +213,8 @@ def _apply_service_env(
         # service has no environment definition
         if 'environment' not in compose_data['services'][service]:
             compose_data['services'][service]['environment'] = {
-                env.name: self._get_env_compose_value(env) for env in envs
+                env.get_name(): self._get_env_compose_value(env)
+                for env in envs
             }
             return compose_data
         # service environment is a map
@@ -238,9 +239,9 @@ def _get_service_new_env_map(
     ) -> Mapping[str, str]:
         new_service_envs: Mapping[str, str] = {}
         for env in new_envs:
-            if env.name in service_env_map:
+            if env.get_name() in service_env_map:
                 continue
-            new_service_envs[env.name] = self._get_env_compose_value(env)
+            new_service_envs[env.get_name()] = self._get_env_compose_value(env)
         return new_service_envs
 
     def _get_service_new_env_list(
@@ -250,17 +251,17 @@ def _get_service_new_env_list(
         for env in new_envs:
             should_be_added = 0 == len([
                 service_env for service_env in service_env_list
-                if service_env.startswith(env.name + '=')
+                if service_env.startswith(env.get_name() + '=')
             ])
             if not should_be_added:
                 continue
             new_service_envs.append(
-                env.name + '=' + self._get_env_compose_value(env)
+                env.get_name() + '=' + self._get_env_compose_value(env)
             )
         return new_service_envs
 
     def _get_env_compose_value(self, env: Env) -> str:
-        return '${' + env.name + ':-' + env.default + '}'
+        return '${' + env.get_name() + ':-' + env.get_default() + '}'
 
     def _get_compose_runtime_file(self, compose_file_name: str) -> str:
         directory, file = os.path.split(compose_file_name)

src/zrb/task_env/env.py

@@ -19,11 +19,20 @@ def __init__(
     ):
         if name in RESERVED_ENV_NAMES:
             raise ValueError(f'Forbidden input name: {name}')
-        self.name: str = name
-        self.os_name: str = os_name if os_name is not None else name
-        self.default: str = default
+        self._name: str = name
+        self._os_name: str = os_name if os_name is not None else name
+        self._default: str = default
         self.should_render: bool = should_render
 
+    def get_name(self) -> str:
+        return self._name
+
+    def get_os_name(self) -> str:
+        return self._os_name
+
+    def get_default(self) -> str:
+        return self._default
+
     def get(self, prefix: str = '') -> str:
         '''
         Return environment value.
@@ -41,22 +50,22 @@ def get(self, prefix: str = '') -> str:
         print(env.get('STAG'))  # will show '0.0.0.0'
         ```
         '''
-        if self.os_name == '':
-            return self.default
-        prefixed_name = self._get_prefixed_name(self.os_name, prefix)
+        if self._os_name == '':
+            return self._default
+        prefixed_name = self.__get_prefixed_name(self._os_name, prefix)
         if prefixed_name in os.environ and os.environ[prefixed_name] != '':
             return os.environ[prefixed_name]
-        if self.os_name in os.environ and os.environ[self.os_name] != '':
-            return os.environ[self.os_name]
-        return self.default
+        if self._os_name in os.environ and os.environ[self._os_name] != '':
+            return os.environ[self._os_name]
+        return self._default
 
-    def _get_prefixed_name(self, name: str, prefix: str):
+    def __get_prefixed_name(self, name: str, prefix: str):
         if prefix is None or prefix == '':
             return name
         return prefix + '_' + name
 
     def __repr__(self) -> str:
-        name = self.name
-        os_name = self.os_name
-        default = self.default
+        name = self._name
+        os_name = self._os_name
+        default = self._default
         return f'<Env name={name} os_name={os_name} default={default}>'

src/zrb/task_env/env_file.py

@@ -14,34 +14,34 @@ def __init__(
         prefix: Optional[str] = None,
         should_render: bool = False
     ):
-        self.env_file = env_file
-        self.prefix = prefix.upper() if prefix is not None else None
-        self.should_render = should_render
-        self._env_list: List[Env] = []
-        self._env_list_fetched: bool = False
+        self._env_file = env_file
+        self._prefix = prefix.upper() if prefix is not None else None
+        self._should_render = should_render
+        self.__env_list: List[Env] = []
+        self.__env_list_fetched: bool = False
 
     def get_envs(self) -> List[Env]:
-        if self._env_list_fetched:
-            return self._env_list
+        if self.__env_list_fetched:
+            return self.__env_list
         env_list: List[Env] = []
-        env_map = dotenv_values(self.env_file)
+        env_map = dotenv_values(self._env_file)
         for key, value in env_map.items():
             if key in RESERVED_ENV_NAMES:
                 continue
             os_name: Optional[str] = None
-            if self.prefix is not None and self.prefix != '':
-                os_name = f'{self.prefix}_{key}'
+            if self._prefix is not None and self._prefix != '':
+                os_name = f'{self._prefix}_{key}'
             env_list.append(Env(
                 name=key,
                 os_name=os_name,
                 default=value,
-                should_render=self.should_render
+                should_render=self._should_render
             ))
-        self._env_list = env_list
-        self._env_list_fetched = True
+        self.__env_list = env_list
+        self.__env_list_fetched = True
         return env_list
 
     def __repr__(self) -> str:
-        env_file = self.env_file
-        prefix = self.prefix
+        env_file = self._env_file
+        prefix = self._prefix
         return f'<EnvFile file={env_file} prefix={prefix}>'