refactor(name): changes internal var/method prefix from __ to _

src/dictrule/built_in_rules/comment_rule.py

@@ -90,7 +90,7 @@ def __init__(
                     prefix (str): prefix for each line
                 """
 
-                self.__prefix = prefix
+                self._prefix = prefix
 
             @staticmethod
             @property
@@ -101,7 +101,7 @@ def style() -> "CommentRule.Style":
             def prefix(self) -> str:
                 """Getter for `prefix` property"""
 
-                return self.__prefix
+                return self._prefix
 
         class MultilineComment(Comment):
             """Multiline comment by comment open, comment close, and prefix for each line"""
@@ -167,20 +167,20 @@ def __init__(
                     Defaults to None.
             """
 
-            self.__singleline = singleline
-            self.__multiline = multiline
+            self._singleline = singleline
+            self._multiline = multiline
 
         @property
         def singleline(self) -> SinglelineComment:
             """Getter for `singleline` property"""
 
-            return self.__singleline
+            return self._singleline
 
         @property
         def multiline(self) -> MultilineComment:
             """Getter for `multiline` property"""
 
-            return self.__multiline
+            return self._multiline
 
     class Style(Enum):
         """Enumeration defining comment styles"""

src/dictrule/built_in_rules/eval_rule.py

@@ -88,15 +88,15 @@ def __init__(
                 value (Any): value of eval name
             """
 
-            self.__key = key
-            self.__value = value
+            self._key = key
+            self._value = value
 
         @property
         def name(self) -> str:
-            return self.__key
+            return self._key
 
         def run(self, cmd: str) -> Any:
-            return self.__value
+            return self._value
 
     class ContextCase(Context.Case):
         """`Context.Case` for `EvalRule`.
@@ -125,13 +125,13 @@ def name(self) -> str:
         def evaluator_list(self) -> List["EvalRule.Evaluable"]:
             """Getter for `evaluator_list` property"""
 
-            return self.__evaluator_list
+            return self._evaluator_list
 
         @property
         def fallback(self) -> Optional["EvalRule.Evaluable"]:
             """Getter for `fallback` property"""
 
-            return self.__fallback
+            return self._fallback
 
         def __init__(
             self,
@@ -146,8 +146,8 @@ def __init__(
                     Defaults to None.
             """
 
-            self.__evaluator_list = list(evaluators)
-            self.__fallback = fallback
+            self._evaluator_list = list(evaluators)
+            self._fallback = fallback
             nonprefix_evaluators: Dict[str, EvalRule.Evaluable] = {}
             prefix_evaluators: Dict[str, EvalRule.Evaluable] = {}
 
@@ -157,8 +157,8 @@ def __init__(
                 else:
                     nonprefix_evaluators[evaluator.name] = evaluator
 
-            self.__evaluators = nonprefix_evaluators
-            self.__prefix_evaluators = prefix_evaluators
+            self._evaluators = nonprefix_evaluators
+            self._prefix_evaluators = prefix_evaluators
 
         def eval(
             self,
@@ -173,21 +173,21 @@ def eval(
                 Optional[Any]: Evaluated value.
             """
 
-            eval_rule = self.__evaluators.get(eval_name)
+            eval_rule = self._evaluators.get(eval_name)
             if not eval_rule:
-                eval_rule = self.__find_eval_by_prefix(
+                eval_rule = self._find_eval_by_prefix(
                     eval_name=eval_name,
                 )
 
             if not eval_rule:
-                if self.__fallback:
-                    return self.__fallback.run(eval_name)
+                if self._fallback:
+                    return self._fallback.run(eval_name)
                 return None
 
             return eval_rule.run(eval_name)
 
         @lru_cache(maxsize=1024)
-        def __find_eval_by_prefix(
+        def _find_eval_by_prefix(
             self,
             eval_name: str,
         ) -> Optional["EvalRule.Evaluable"]:
@@ -200,7 +200,7 @@ def __find_eval_by_prefix(
                 Optional[EvalRule.Evaluable]: The evaluator found by prefix.
             """
 
-            for name, evaluator in self.__prefix_evaluators.items():
+            for name, evaluator in self._prefix_evaluators.items():
                 if eval_name.startswith(name):
                     return evaluator
 

src/dictrule/built_in_rules/for_in_rule.py

@@ -89,7 +89,7 @@ class ForInEval(EvalRule.Evaluable):
         def name(self) -> str:
             """Getter for `name` property"""
 
-            return self.__var_name
+            return self._var_name
 
         @property
         def prefix_matching(self) -> bool:
@@ -111,9 +111,9 @@ def __init__(
                 extra_properties (Dict[str, Any]): A map of variable names and values.
             """
 
-            self.__var_name = str(var_name)
-            self.__var = var
-            self.__extra_properties = dict(extra_properties)
+            self._var_name = str(var_name)
+            self._var = var
+            self._extra_properties = dict(extra_properties)
 
         def run(
             self,
@@ -130,17 +130,17 @@ def run(
                 str: The result of the execution.
             """
 
-            var_prefix = self.__var_name + "."
+            var_prefix = self._var_name + "."
             if not cmd.startswith(var_prefix):
-                return self.__var
+                return self._var
 
             properties = cmd.split(".")
             property_value = ""
             extra_prop = ".".join(properties[1:])
-            if extra_prop in self.__extra_properties:
-                property_value = self.__extra_properties[extra_prop]
+            if extra_prop in self._extra_properties:
+                property_value = self._extra_properties[extra_prop]
             else:
-                local_var = self.__var
+                local_var = self._var
                 for prop in properties[1:]:
                     callable_var = getattr(local_var, prop)
                     if callable(callable_var):

src/dictrule/built_in_rules/indent_rule.py

@@ -58,13 +58,13 @@ def __init__(
                 num_spaces (int): The number of spaces for each level of indentation.
             """
 
-            self.__num_spaces = num_spaces
+            self._num_spaces = num_spaces
 
         @property
         def num_spaces(self) -> int:
             """Getter for `num_spaces` property"""
 
-            return self.__num_spaces
+            return self._num_spaces
 
     @dr_property(prefix_matching=True)
     def _indent(self, props: Dict[str, Any]) -> Any:

src/dictrule/context.py

@@ -42,7 +42,7 @@ def __init__(
             cases (List[Case]): List of `Context.Case` to build the case map
         """
 
-        self.__cases = list(cases)
+        self._cases = list(cases)
         case_map: Dict[str, Context.Case] = {}
         for case in cases:
             if case.name in case_map:
@@ -56,7 +56,7 @@ def __init__(
 
             case_map[case.name] = case
 
-        self.__case_map = case_map
+        self._case_map = case_map
 
     @property
     def cases(self) -> List[Case]:
@@ -65,7 +65,7 @@ def cases(self) -> List[Case]:
         Returns:
             List[Case]: list of cases
         """
-        return self.__cases
+        return self._cases
 
     @property
     def case_map(self) -> Dict[str, Case]:
@@ -75,7 +75,7 @@ def case_map(self) -> Dict[str, Case]:
             Dict[str, Case]: map of cases [name: str, case: Context.Case]
         """
 
-        return self.__case_map
+        return self._case_map
 
     def get(self, name: str) -> Optional[Case]:
         """Gets the case by name
@@ -88,4 +88,4 @@ def get(self, name: str) -> Optional[Case]:
                 built from `Context` creation
         """
 
-        return self.__case_map.get(name)
+        return self._case_map.get(name)

src/dictrule/dr_property.py

@@ -49,8 +49,8 @@ def __init__(
                 Defaults to False.
         """
 
-        self.__optional = optional
-        self.__prefix_matching = prefix_matching
+        self._optional = optional
+        self._prefix_matching = prefix_matching
 
     def __call__(
         self,
@@ -61,7 +61,7 @@ def __call__(
         key = func.__name__[len(dr_property._prefix) :]
         setattr(func, dr_property._flag_key, True)
         setattr(func, dr_property._name_key, key)
-        setattr(func, dr_property._optional_key, self.__optional)
+        setattr(func, dr_property._optional_key, self._optional)
 
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
@@ -73,7 +73,7 @@ def wrapper(*args, **kwargs):
             if not isinstance(props, Dict):
                 raise InvalidTypeException(f"First param `{props}` must be a dict")
 
-            if self.__prefix_matching:
+            if self._prefix_matching:
                 for prop, value in props.items():
                     if prop.startswith(key):
                         return (prop, value)

src/dictrule/generator.py

@@ -69,22 +69,22 @@ def __init__(
         if parse_rules is None:
             parse_rules = Generator.STD_RULES
 
-        self.__cache_rules: Dict[str, Rule] = {}
-        self.__gen_rules = list(gen_rules)
-        self.__parse_rules: List[Rule] = []
+        self._cache_rules: Dict[str, Rule] = {}
+        self._gen_rules = list(gen_rules)
+        self._parse_rules: List[Rule] = []
         self.add_parse_rules(parse_rules)
 
     @property
     def parse_rules(self) -> List[Rule]:
         """Getter for `parse_rules` property"""
 
-        return self.__parse_rules
+        return self._parse_rules
 
     @property
     def gen_rules(self) -> List[Union[str, Dict[str, Any]]]:
         """Getter for `gen_rules` property"""
 
-        return self.__gen_rules
+        return self._gen_rules
 
     def add_parse_rule(
         self,
@@ -96,7 +96,7 @@ def add_parse_rule(
             rule (Rule): The rule subclass to add.
         """
 
-        self.__parse_rules.append(rule)
+        self._parse_rules.append(rule)
 
     def add_parse_rules(
         self,
@@ -125,8 +125,8 @@ def generate(
             str: Generated text
         """
 
-        def __rule_from_dict(rule_dict: Dict[str, Any]) -> Rule:
-            rule = self.__parse_rule_from_dict(rule_dict)
+        def _rule_from_dict(rule_dict: Dict[str, Any]) -> Rule:
+            rule = self._parse_rule_from_dict(rule_dict)
             if not rule:
                 pass
 
@@ -135,7 +135,7 @@ def __rule_from_dict(rule_dict: Dict[str, Any]) -> Rule:
 
             return rule
 
-        def __internal_parse_rule(
+        def _internal_parse_rule(
             context: Optional[Context],
             rule: Any,
         ) -> str:
@@ -148,41 +148,41 @@ def __internal_parse_rule(
             if not isinstance(rule, Dict):
                 raise InvalidTypeException(f"Rule {rule} must be a dict")
 
-            found_rule = __rule_from_dict(rule)
+            found_rule = _rule_from_dict(rule)
             parsed = found_rule.parse(
                 rule_dict=rule,
                 context=context,
-                rule_callback=__internal_parse_rule,
+                rule_callback=_internal_parse_rule,
             )
 
             return parsed
 
-        self.__parse_rules.sort(
+        self._parse_rules.sort(
             key=lambda r: len(r.dr_non_optional_props),
             reverse=True,
         )
 
         output: List[str] = []
-        for rule in self.__gen_rules:
-            parsed = __internal_parse_rule(
+        for rule in self._gen_rules:
+            parsed = _internal_parse_rule(
                 context=context,
                 rule=rule,
             )
             output.append(parsed)
 
         return "\n".join(output)
 
-    def __parse_rule_from_dict(
+    def _parse_rule_from_dict(
         self,
         rule_dict: Dict[str, Any],
     ) -> Optional[Rule]:
         dict_keys = set(rule_dict.keys())
-        key = self.__key_from_keys(dict_keys)
-        rule = self.__cache_rules.get(key)
+        key = self._key_from_keys(dict_keys)
+        rule = self._cache_rules.get(key)
         if rule:
             return rule
 
-        for rule in self.__parse_rules:
+        for rule in self._parse_rules:
             props: Set[str] = set()
             for prop in rule.dr_non_optional_props:
                 prop_name, prop_value = prop(rule_dict)
@@ -199,7 +199,7 @@ def __parse_rule_from_dict(
 
         return None
 
-    def __key_from_keys(
+    def _key_from_keys(
         self,
         keys: Set[str],
     ) -> str: