yta-programming-env 0.3.2__tar.gz → 0.4.0__tar.gz

{yta_programming_env-0.3.2 → yta_programming_env-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yta-programming-env
-Version: 0.3.2
+Version: 0.4.0
 Summary: Youtube Autonomous Programming Dependencies Module
 License-File: LICENSE
 Author: danialcala94

{yta_programming_env-0.3.2 → yta_programming_env-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-programming-env"
-version = "0.3.2"
+version = "0.4.0"
 description = "Youtube Autonomous Programming Dependencies Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

yta_programming_env-0.4.0/src/yta_programming_env/__init__.py

@@ -0,0 +1,208 @@
+from yta_programming_path import DevPathHandler
+from yta_validation.parameter import ParameterValidator
+from dotenv import load_dotenv, dotenv_values
+from typing import Union
+
+import os
+
+
+class Environment:
+    """
+    Class to handle the environment of the project in
+    which you are executing this code perfectly.
+    """
+
+
+    @staticmethod
+    def load_dotenv(
+        env_filename: str = '.env',
+        do_override: bool = True,
+        do_use_project_abspath: bool = True
+    ) -> None:
+        """
+        Load the `env_filename` (by default '.env')
+        environment configuration file from the current
+        project.
+
+        The `env_filename` will be read and the variables
+        on it will be loaded and ready to be accessed by
+        using the methods in this `Environment` class,
+        that will use the `os.getenv()`.
+
+        If the `do_override` is `True`, the previously 
+        existing configuration variables will be overriden by
+        the new values.
+        """
+        dotenv_path = (
+            os.path.join(
+                DevPathHandler.get_project_abspath(),
+                env_filename
+            )
+            if do_use_project_abspath else
+            env_filename
+        )
+
+        load_dotenv(
+            dotenv_path = dotenv_path,
+            override = do_override
+        )
+
+        return None
+
+
+    @staticmethod
+    def get_dotenv(
+        env_filename: str = '.env',
+        do_use_project_abspath: bool = True
+    ) -> dict:
+        """
+        Get the variables of the `env_filename` environment
+        configuration file as a dict.
+
+        This method doesn't load the variables in memory, it
+        just read the values from the file.
+
+        It will join the project abspath and the
+        `env_filename` if the `do_use_project_abspath` is 
+        `True`.
+        """
+        dotenv_path = (
+            os.path.join(
+                DevPathHandler.get_project_abspath(),
+                env_filename
+            )
+            if do_use_project_abspath else
+            env_filename
+        )
+
+        return dotenv_values(
+            dotenv_path = dotenv_path
+        )
+    
+
+    @staticmethod
+    def load_variable(
+        variable: str,
+        default_value: Union[str, bool, float, int, None] = None,
+        env_filename: str = '.env',
+        do_use_abspath: bool = True
+    ) -> Union[str, bool, float, int, None]:
+        """
+        Get the `variable` from the `env_filename` file and
+        load it into the environment variables, using the
+        `default_value` if not found.
+
+        This will load only the `variable` specified, if
+        existing, or set the `default_value` instead, and
+        will overwrite any previous value.
+        """
+        environment_variables = Environment.get_dotenv(
+            env_filename = env_filename,
+            do_use_project_abspath = do_use_abspath
+        )
+
+        value = environment_variables.get(variable, default_value)
+
+        Environment.set_variable(
+            variable = variable,
+            value = value
+        )
+
+        return value
+    
+
+    # @staticmethod
+    # def get_variable_loading(
+    #     variable: str,
+    #     default_value: Union[str, bool, float, int, None] = None,
+    #     env_filename: str = '.env',
+    #     do_override: bool = True,
+    #     do_use_project_abspath: bool = True
+    # ) -> Union[str, bool, float, int, None]:
+    #     """
+    #     Get the `variable` from the `os` environment by 
+    #     loading the dotenv and returning the value of that
+    #     `variable`, or the `default_value` if not found and
+    #     provided.
+
+    #     This method will perform an `Environment.load_dotenv()`
+    #     before accessing to the variable.
+    #     """
+    #     Environment.load_dotenv(
+    #         env_filename = env_filename,
+    #         do_override = do_override,
+    #         do_use_project_abspath = do_use_project_abspath
+    #     )
+
+    #     return Environment.get_variable(variable, default_value)
+    
+
+    @staticmethod
+    def get_variable_from_dotenv(
+        variable: str,
+        default_value: Union[str, bool, float, int, None] = None,
+        env_filename: str = '.env',
+        do_use_abspath: bool = True
+    ) -> Union[str, bool, float, int, None]:
+        """
+        Read the `variable` from the `env_filename` dotenv
+        file and return it or the `default_value` if not
+        found.
+
+        This method doesn't load the variables into memory.
+        """
+        return Environment.get_dotenv(
+            env_filename = env_filename,
+            do_use_project_abspath = do_use_abspath
+        ).get(variable, default_value)
+
+
+    @staticmethod
+    def get_variable(
+        variable: str,
+        default_value: Union[str, bool, float, int, None] = None,
+    ) -> Union[str, bool, float, int, None]:
+        """
+        Get the `variable` from the `os` environment by doing
+        a `os.getenv(variable)`, receiving the `default_value`
+        if not existing and provided.
+        """
+        return os.getenv(variable, default_value)
+
+
+    @staticmethod
+    def set_variable(
+        variable: str,
+        value: Union[str, bool, float, int]
+    ) -> Union[str, None]:
+        """
+        Set the value of the `variable` in the environment by
+        doing `os.environ[variable] = value`.
+
+        The environment variables are always strings.
+
+        This method will return the value the environment
+        variable had before setting the new one, if existing.
+        """
+        previous_value = os.getenv(variable, None)
+        
+        os.environ[variable] = str(value)
+
+        return previous_value
+
+
+    @staticmethod
+    def remove_variable(
+        variable: str,
+        default_value: Union[str, bool, float, int, None] = None
+    ) -> Union[str, None]:
+        """
+        Unset the `variable` in the environment by doing 
+        `os.environ.pop[variable]`.
+
+        This method will return the last value before
+        unsetting it, if existing, or the `default_value`
+        if provided and not found in the environment
+        variables.
+        """
+        return os.environ.pop(variable, default_value)

yta_programming_env-0.3.2/src/yta_programming_env/__init__.py

@@ -1,84 +0,0 @@
-from yta_programming_path import DevPathHandler
-from yta_validation.parameter import ParameterValidator
-from dotenv import load_dotenv, dotenv_values
-from typing import Union
-
-import os
-
-
-class Environment:
-    """
-    Class to handle the environment of the project in
-    which you are executing this code perfectly.
-    """
-
-    @staticmethod
-    def load_current_project_dotenv(
-        env_filename: str = '.env',
-        do_override: bool = True
-    ):
-        """
-        Load the `env_filename` (by default '.env')
-        environment configuration file from the current
-        project. The current project is the one in which
-        the code is being executed, not the library in which
-        it is written.
-
-        The `env_filename` will be read and the variables on
-        it will be loaded and ready to be accessed.
-
-        If the `do_override` is `True`, the previously 
-        existing configuration variables will be overriden by
-        the new values.
-        """
-        load_dotenv(
-            dotenv_path = os.path.join(DevPathHandler.get_project_abspath(), env_filename),
-            override = do_override
-        )
-
-    @staticmethod
-    def get_current_project_env_dict(
-        env_filename: str = '.env'
-    ) -> dict:
-        """
-        Get the variables of the `env_filename` environment
-        configuration file as a dict.
-
-        This method doesn't load the variables in memory, it
-        just read the values from the file.
-        """
-        return dotenv_values(
-            dotenv_path = os.path.join(
-                DevPathHandler.get_project_abspath(),
-                env_filename
-            )
-        )
-        
-    @staticmethod
-    def get_current_project_env(
-        variable: str,
-        default_value: Union[str, bool, float, int, None] = None,
-        env_filename: str = '.env'
-    ):
-        """
-        Load the `env_filename` environment configuration file
-        and get the value of the `variable`, if existing.
-
-        This method will do a `load_dotenv` call, which will
-        try to load the `env_filename` in memory and then use
-        the `os.getenv` method.
-        """
-        ParameterValidator.validate_mandatory_string('variable', variable, do_accept_empty = False)
-
-        return Environment.get_current_project_env_dict(env_filename).get(variable, default_value)
-    
-    @staticmethod
-    def get_env(
-        variable: str,
-        default_value: Union[str, bool, float, int, None] = None,
-    ):
-        """
-        Get the `variable` from the `os` environment by doing
-        a `os.getenv(variable)`.
-        """
-        return os.getenv(variable, default_value)