xenoslib 0.1.30__py3-none-any.whl → 0.3.0__py3-none-any.whl

xenoslib/about.py

@@ -4,4 +4,4 @@ __url__ = "https://github.com/XenosLu/xenoslib.git"
 __author__ = "Xenocider"
 __author_email__ = "xenos.lu@gmail.com"
 __license__ = "MIT License"
-__version__ = "0.1.30"
+__version__ = "0.3.0"

xenoslib/base.py

@@ -4,6 +4,68 @@ import argparse
 import sys
 import time
 import inspect
+import logging
+import os
+
+from logging.handlers import TimedRotatingFileHandler
+
+
+def init_logger(
+    use_file: bool = True,
+    level: int = logging.INFO,
+    backup_count: int = 0,  # New parameter: number of log files to retain (0 means keep all)
+) -> logging.Logger:
+    """
+    Automatically names logger after caller's filename, rotates by time, and retains specified number of log files
+
+    Args:
+        use_file: Whether to enable file logging
+        level: Logging level (DEBUG/INFO/WARN/ERROR)
+        backup_count: Number of historical log files to retain (default 0=keep all)
+    """
+    # 1. Dynamically get caller's filename
+    caller_frame = inspect.stack()[1]
+    caller_path = caller_frame.filename
+    caller_name = os.path.splitext(os.path.basename(caller_path))[0]
+
+    # 2. Configure log directory and filename
+    log_dir = "logs"
+    os.makedirs(log_dir, exist_ok=True)
+    log_filename = f"{caller_name}.log"
+    full_path = os.path.join(log_dir, log_filename)
+
+    # 3. Avoid duplicate initialization
+    logger = logging.getLogger(caller_name)
+    if logger.hasHandlers():
+        return logger
+
+    logger.setLevel(level)
+    formatter = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(filename)s:%(lineno)d - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+    )
+
+    # 4. Console handler (required)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    handlers = [console_handler]
+
+    # 5. File handler (daily rotation + file retention policy)
+    if use_file:
+        file_handler = TimedRotatingFileHandler(
+            full_path,
+            when="midnight",  # Rotate daily
+            interval=1,
+            backupCount=backup_count,  # Key parameter: controls number of retained files
+            encoding="utf-8",
+        )
+        file_handler.setFormatter(formatter)
+        handlers.append(file_handler)
+
+    for handler in handlers:
+        logger.addHandler(handler)
+
+    return logger
 
 
 def sleep(seconds, mute=False):

xenoslib/tools/config_loader.py

@@ -28,36 +28,37 @@ class ConfigLoader(SingletonWithArgs):
 
         # With Vault (hvac imported on demand)
         >>> config = ConfigLoader("config.yml", vault_secret_id="my-secret-id")
+
+        # Write to Vault using attribute style
+        >>> config.test_section.test_key = "new_value"
+
+        # Write to Vault using dictionary style
+        >>> config["test_section"]["test_key"] = "new_value"
     """
 
+    VAULT_SUFFIX = "@vault"
+    KV_MOUNT_POINT = "kv"
+
     cache = {}
     vault_client = None
 
     def __init__(self, config_file_path="config.yml", vault_secret_id=None):
         """Initialize the ConfigLoader with a configuration file and optional Vault secret."""
         with open(config_file_path, "r") as f:
-            self._raw_config = yaml.safe_load(f) or {}
+            config_data = yaml.safe_load(f)
+            self._raw_config = config_data if isinstance(config_data, dict) else {}
 
         if vault_secret_id is not None:
             self.vault_secret_id = vault_secret_id
             self._check_and_renew_vault_client()
 
     def _init_vault_client(self):
-        """Initialize and authenticate the Vault client (imports hvac on demand).
-
-        Args:
-            vault_secret_id (str): Secret ID for Vault authentication.
-
-        Raises:
-            ImportError: If hvac package is not installed.
-            KeyError: If required Vault configuration is missing.
-            Exception: If Vault authentication fails.
-        """
+        """Initialize and authenticate the Vault client (imports hvac on demand)."""
         try:
             import hvac  # Lazy import
         except ImportError as e:
             raise ImportError(
-                "hvac package is required for Vault integration. " "Install with: pip install hvac"
+                "hvac package is required for Vault integration. Install with: pip install hvac"
             ) from e
 
         try:
@@ -75,84 +76,113 @@ class ConfigLoader(SingletonWithArgs):
             )
         except Exception as e:
             self.vault_client = None
-            raise Exception(f"Failed to initialize Vault client: {str(e)}")
+            raise Exception(f"Failed to initialize Vault client: {str(e)}") from e
 
     def _check_and_renew_vault_client(self):
-        # 检查当前Token的状态，包括过期时间和可续租性
         if not self.vault_client or not self.vault_client.is_authenticated():
-            # 如果当前Token无效，则重新认证
             self._init_vault_client()
 
+    def _is_vault_reference(self, section_config, key_name):
+        """检查键是否是Vault引用"""
+        return f"{key_name}{self.VAULT_SUFFIX}" in section_config
+
     def get(self, section, key_name, use_cache=True):
-        """Retrieve a configuration value.
-
-        Args:
-            section (str): The configuration section name.
-            key_name (str): The key name within the section.
-            use_cache (bool): Whether to use cached values. Defaults to True.
-
-        Returns:
-            The configuration value, which may come from:
-            - Direct configuration value
-            - Vault secret (if Vault is initialized)
-            - Cache (if enabled)
-
-        Raises:
-            KeyError: If the section or key is not found.
-            Exception: If Vault access is required but not available.
-        """
-        if section not in self._raw_config:
+        """Retrieve a configuration value."""
+        section_config = self._raw_config.get(section)
+        if section_config is None:
             raise KeyError(f"Section '{section}' not found")
 
-        # Check for direct value first
-        if key_name in self._raw_config[section]:
-            return self._raw_config[section][key_name]
+        if key_name in section_config:
+            return section_config[key_name]
 
-        # Handle Vault reference if Vault is enabled
-        vault_key = f"{key_name}@vault"
-        if vault_key in self._raw_config[section]:
+        if self._is_vault_reference(section_config, key_name):
             if self.vault_client is None:
                 raise Exception(
                     f"Vault access required for {key_name} but Vault is not initialized"
                 )
 
-            cache_key = f"{section}_{key_name}"
-
+            cache_key = f"{section}:{key_name}"
             if use_cache and cache_key in self.cache:
                 return self.cache[cache_key]
             value = self._get_value_from_vault(section, key_name)
             self.cache[cache_key] = value
             return value
 
-        raise KeyError(f"Key '{key_name}' or '{vault_key}' not found in section '{section}'")
+        raise KeyError(f"Key '{key_name}' not found in section '{section}'")
 
-    def _get_value_from_vault(self, section, key_name):
-        """Retrieve a secret value from Vault.
+    def set(self, section, key_name, value, use_cache=True):
+        """Set a configuration value to Vault."""
+        section_config = self._raw_config.get(section)
+        if section_config is None:
+            raise KeyError(f"Section '{section}' not found")
 
-        Args:
-            section (str): The configuration section name.
-            key_name (str): The key name within the section.
+        if not self._is_vault_reference(section_config, key_name):
+            raise KeyError(f"Key '{key_name}' is not a Vault reference in section '{section}'")
 
-        Returns:
-            The secret value from Vault.
+        if self.vault_client is None:
+            raise Exception(f"Vault access required for {key_name} but Vault is not initialized")
 
-        Raises:
-            Exception: If Vault access fails.
-        """
+        self._set_value_to_vault(section, key_name, value)
+
+        cache_key = f"{section}:{key_name}"
+        if use_cache:
+            self.cache[cache_key] = value
+
+    def _get_value_from_vault(self, section, key_name):
+        """Retrieve a secret value from Vault."""
         try:
-            vault_path = self._raw_config[section]["vault_path"]
-            vault_key = self._raw_config[section][f"{key_name}@vault"]
-            vault_namepsace = self._raw_config[section].get("vault_namespace")
-            if vault_namepsace:
-                self.vault_client.adapter.namespace = vault_namepsace
-            else:
-                self.vault_client.adapter.namespace = self._raw_config["vault"]["space"]
+            section_config = self._raw_config[section]
+            vault_path = section_config.get("vault_path")
+            if not vault_path:
+                raise KeyError(f"Missing vault_path in section '{section}'")
+
+            vault_key_ref = f"{key_name}{self.VAULT_SUFFIX}"
+            vault_key = section_config[vault_key_ref]
+
+            namespace = section_config.get("vault_namespace") or self._raw_config["vault"]["space"]
+            self.vault_client.adapter.namespace = namespace
+
             data = self.vault_client.secrets.kv.read_secret_version(
-                path=vault_path, mount_point="kv", raise_on_deleted_version=True
+                path=vault_path, mount_point=self.KV_MOUNT_POINT, raise_on_deleted_version=True
             )
             return data["data"]["data"][vault_key]
         except Exception as e:
-            raise Exception(f"Failed to fetch {key_name} from Vault: {str(e)}")
+            raise Exception(f"Failed to fetch {key_name} from Vault: {str(e)}") from e
+
+    def _set_value_to_vault(self, section, key_name, value):
+        """Set a secret value to Vault."""
+        try:
+            self._check_and_renew_vault_client()
+
+            section_config = self._raw_config[section]
+            vault_path = section_config.get("vault_path")
+            if not vault_path:
+                raise KeyError(f"Missing vault_path in section '{section}'")
+
+            vault_key_ref = f"{key_name}{self.VAULT_SUFFIX}"
+            vault_key = section_config[vault_key_ref]
+
+            namespace = section_config.get("vault_namespace") or self._raw_config["vault"]["space"]
+            self.vault_client.adapter.namespace = namespace
+
+            try:
+                data = self.vault_client.secrets.kv.read_secret_version(
+                    path=vault_path, mount_point=self.KV_MOUNT_POINT, raise_on_deleted_version=True
+                )
+                secret_data = data["data"]["data"]
+            except Exception:
+                logger.warning(f"Secret not found, creating new secret at {vault_path}")
+                secret_data = {}
+
+            secret_data[vault_key] = value
+
+            self.vault_client.secrets.kv.create_or_update_secret(
+                path=vault_path, secret=secret_data, mount_point=self.KV_MOUNT_POINT
+            )
+
+            logger.info(f"Updated Vault secret: {vault_path}/{vault_key}")
+        except Exception as e:
+            raise Exception(f"Failed to set {key_name} to Vault: {str(e)}") from e
 
     def __getitem__(self, section):
         """Dictionary-style access to configuration sections."""
@@ -160,6 +190,10 @@ class ConfigLoader(SingletonWithArgs):
             raise KeyError(f"Section '{section}' not found")
         return SectionProxy(self, section)
 
+    def __setitem__(self, section, proxy):
+        """Prevent direct assignment to sections."""
+        raise TypeError("ConfigLoader does not support direct section assignment")
+
     def __getattr__(self, section):
         """Attribute-style access to configuration sections."""
         try:
@@ -179,6 +213,10 @@ class SectionProxy:
         """Dictionary-style access to configuration values."""
         return self._loader.get(self._section, key)
 
+    def __setitem__(self, key, value):
+        """Dictionary-style setting of configuration values to Vault."""
+        self.set(key, value)
+
     def get(self, key, default=None):
         """Dictionary-style access to configuration values."""
         try:
@@ -186,6 +224,10 @@ class SectionProxy:
         except KeyError:
             return default
 
+    def set(self, key, value):
+        """Set a configuration value to Vault."""
+        self._loader.set(self._section, key, value)
+
     def __getattr__(self, key):
         """Attribute-style access to configuration values."""
         try:
@@ -193,6 +235,13 @@ class SectionProxy:
         except KeyError as e:
             raise AttributeError(str(e))
 
+    def __setattr__(self, name, value):
+        """Attribute-style setting of configuration values to Vault."""
+        if name.startswith("_"):
+            super().__setattr__(name, value)
+        else:
+            self.set(name, value)
+
     def __repr__(self):
         """String representation of the section's configuration."""
         return yaml.dump(self._loader._raw_config[self._section])
@@ -202,10 +251,40 @@ if __name__ == "__main__":
     config_without_vault = ConfigLoader("config.yml")
     print("Without Vault:", config_without_vault.get("jira", "url"))
 
-    # This will only work if you provide a valid Vault secret ID
-    # and hvac package is installed
     config_with_vault = ConfigLoader("config.yml", vault_secret_id=os.getenv("VAULT_SECRET_ID"))
 
-    print("With Vault:", config_with_vault.test.test)
-    print("With Vault:", config_with_vault["cis"]["cis_client_id"])
+    # 属性方式读取
+    print("With Vault (attr):", config_with_vault.test.test)
+
+    # 字典方式读取
+    print("With Vault (dict):", config_with_vault["cis"]["cis_client_id"])
+
+    # 测试不存在的值
     print("Try val not exists: ", config_with_vault.test.get("not_exists"))
+
+    # 写入示例 - 属性方式
+    try:
+        print("Current test value (attr read):", config_with_vault.test.test)
+        config_with_vault.test.test = "new_value_123"
+        print("After write (attr read):", config_with_vault.test.test)
+    except Exception as e:
+        print("Attribute write failed:", str(e))
+
+    # 写入示例 - 字典方式
+    try:
+        print("Current test value (dict read):", config_with_vault["test"]["test"])
+        config_with_vault["test"]["test"] = "new_value_456"
+        print("After write (dict read):", config_with_vault["test"]["test"])
+
+        # 混合方式验证
+        print("After write (attr read):", config_with_vault.test.test)
+    except Exception as e:
+        print("Dictionary write failed:", str(e))
+
+    # 写入新键示例
+    try:
+        print("Setting new key...")
+        config_with_vault["database"]["new_password"] = "secure123!"
+        print("New password:", config_with_vault.database.new_password)
+    except Exception as e:
+        print("New key write failed:", str(e))

{xenoslib-0.1.30.dist-info → xenoslib-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xenoslib
-Version: 0.1.30
+Version: 0.3.0
 Summary: Xenos' common lib
 Home-page: https://github.com/XenosLu/xenoslib.git
 Author: Xenocider

{xenoslib-0.1.30.dist-info → xenoslib-0.3.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 xenoslib/__init__.py,sha256=vlMWwdD2gTb9ztpm_orYAm_Y0Be0Es64ifvMQwrE1jU,310
 xenoslib/__main__.py,sha256=UpD3pl4l5ZUFxK6FzNMWRb1AZpEnwerulSFoPb_Pdgw,307
-xenoslib/about.py,sha256=B8RIL1Gxy_xbK_YIIS4rzVETE5QvWJ-XGugxrMrhEpY,229
-xenoslib/base.py,sha256=rAXk71AsnWvQ7MaSad5Xxd9Lwucp-cZc15yyqoV5Dk4,12440
+xenoslib/about.py,sha256=JOPWsSbcxv9ls6wxojlF88auWvYf0Ok4vc4yFIolu-Y,228
+xenoslib/base.py,sha256=2qHsptnf_EAaoezr5aQwM6gdPEGnAPn8ommRYtOhD1c,14428
 xenoslib/dev.py,sha256=R6iwKuu-xvaYiBOUyP2gpePyvXss17TOZaCmQEihPCw,1236
 xenoslib/extend.py,sha256=Vl5d8carSGy6ERE2EjTmB9lOo2uIBWs1iz-fKm_TX-M,5947
 xenoslib/linux.py,sha256=EFCQBq_JsmNJc3wGlJlzH9W0tjOA7sSwx0u62R5Ut2k,1318
@@ -11,9 +11,9 @@ xenoslib/onedrive.py,sha256=-bJJ8Cd_RjJSlDynYqKoZlFKE1HHM34l6NXOQrWOwtg,7783
 xenoslib/win_trayicon.py,sha256=7GJwX3c2CS1XWQjsyDK5EfM-MmEHdzPJCTX2sGpWmuU,13115
 xenoslib/windows.py,sha256=lUTD7TowaPqYHgIL6b-GM9PLd-VyJNNGzkzC3K9vOxo,4080
 xenoslib/tools/__init__.py,sha256=D1qP5tD2ZukXHgjKUh0fFl8jUipM3KaPBZBi0vGPypQ,48
-xenoslib/tools/config_loader.py,sha256=K31ksf-cE76aJOqm82ayYIgkwcmk5iAENJNaax5CwNY,7752
-xenoslib-0.1.30.dist-info/licenses/LICENSE,sha256=lF6hjufhiR-xAje_Wo7ogxV5phz2d5TgkfL5SGshujg,1066
-xenoslib-0.1.30.dist-info/METADATA,sha256=Ve9EhjpGDTtOG91V30a1GW9LGQw356f12uyyfkCsBEo,911
-xenoslib-0.1.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xenoslib-0.1.30.dist-info/top_level.txt,sha256=Rfm4GdW0NyA2AHDNUF2wFQOfAo53mAPibddSHGd3X60,9
-xenoslib-0.1.30.dist-info/RECORD,,
+xenoslib/tools/config_loader.py,sha256=dHGqeRX-RvtBCdERsOYTYRIBD8nfYx04XRpps25ob_c,10947
+xenoslib-0.3.0.dist-info/licenses/LICENSE,sha256=lF6hjufhiR-xAje_Wo7ogxV5phz2d5TgkfL5SGshujg,1066
+xenoslib-0.3.0.dist-info/METADATA,sha256=YjQwsxquDj_F_rfl9-GiRVsWRHxmtDE7yh7Q73dKj6g,910
+xenoslib-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xenoslib-0.3.0.dist-info/top_level.txt,sha256=Rfm4GdW0NyA2AHDNUF2wFQOfAo53mAPibddSHGd3X60,9
+xenoslib-0.3.0.dist-info/RECORD,,