Python-Lua-Helper 1.2.0__tar.gz → 1.4.0__tar.gz

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Python-Lua-Helper
-Version: 1.2.0
+Version: 1.4.0
 Summary: Lua configuration system for your Python projects.
 Project-URL: Repository, https://github.com/DarkCaster/Python-Lua-Helper.git
 Author-email: DarkCaster <dark.caster@outlook.com>

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/hatch_build.py

@@ -57,7 +57,7 @@ class CustomBuildHook(BuildHookInterface):
         arch = platform.machine().lower()
         print(f"OS: {current_os}, arch: {arch}")
         # Lua build defines
-        lua_version = "5.4.8"
+        lua_version = "5.5.0"
         lua_src = f"lua-{lua_version}.tar.gz"
         lua_checksum = f"lua-{lua_version}.sha256"
         lua_patch = "build.patch"

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/lua/build-mingw.sh

@@ -8,7 +8,7 @@ arch="$2"
 
 script_dir="$(cd "$(dirname "$0")" && pwd)"
 
-lua_version="5.4.8"
+lua_version="5.5.0"
 lua_src="lua-$lua_version.tar.gz"
 lua_checksum="lua-$lua_version.sha256"
 

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/lua/build.patch

@@ -1,7 +1,7 @@
-diff -uprN lua-5.4.8.old/src/luaconf.h lua-5.4.8/src/luaconf.h
---- lua-5.4.8.old/src/luaconf.h	2025-05-22 00:09:16.000000000 +0300
-+++ lua-5.4.8/src/luaconf.h	2025-11-15 14:39:42.772620831 +0300
-@@ -53,26 +53,22 @@
+diff -uprN lua-5.5.0.old/src/luaconf.h lua-5.5.0/src/luaconf.h
+--- lua-5.5.0.old/src/luaconf.h	2025-12-15 13:44:40.000000000 +0300
++++ lua-5.5.0/src/luaconf.h	2026-02-08 02:46:07.116399878 +0300
+@@ -53,7 +53,6 @@
  
  
  #if defined(LUA_USE_WINDOWS)
@@ -9,16 +9,19 @@ diff -uprN lua-5.4.8.old/src/luaconf.h lua-5.4.8/src/luaconf.h
  #define LUA_USE_C89	/* broadly, Windows is C89 */
  #endif
  
- 
+@@ -69,21 +68,18 @@
+ */
  #if defined(LUA_USE_LINUX)
  #define LUA_USE_POSIX
 -#define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
+ #define LUA_READLINELIB		"libreadline.so"
  #endif
  
  
  #if defined(LUA_USE_MACOSX)
  #define LUA_USE_POSIX
--#define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
+-#define LUA_USE_DLOPEN		/* macOS does not need -ldl */
+ #define LUA_READLINELIB		"libedit.dylib"
  #endif
  
  
@@ -28,25 +31,21 @@ diff -uprN lua-5.4.8.old/src/luaconf.h lua-5.4.8/src/luaconf.h
  #endif
  
  
-diff -uprN lua-5.4.8.old/src/Makefile lua-5.4.8/src/Makefile
---- lua-5.4.8.old/src/Makefile	2023-02-03 13:43:14.000000000 +0300
-+++ lua-5.4.8/src/Makefile	2025-11-15 17:18:54.952610183 +0300
-@@ -123,18 +123,17 @@ ios:
- Linux linux:	linux-noreadline
+diff -uprN lua-5.5.0.old/src/Makefile lua-5.5.0/src/Makefile
+--- lua-5.5.0.old/src/Makefile	2025-07-07 03:19:14.000000000 +0300
++++ lua-5.5.0/src/Makefile	2026-02-08 02:51:17.686297782 +0300
+@@ -121,15 +121,14 @@ ios:
+ 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_IOS"
  
- linux-noreadline:
+ Linux linux:
 -	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl"
 +	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS=""
  
- linux-readline:
--	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" SYSLIBS="-Wl,-E -ldl -lreadline"
-+	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" SYSLIBS="-Wl,-E -lreadline"
- 
  Darwin macos macosx:
  	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX -DLUA_USE_READLINE" SYSLIBS="-lreadline"
  
  mingw:
--	$(MAKE) "LUA_A=lua54.dll" "LUA_T=lua.exe" \
+-	$(MAKE) "LUA_A=lua55.dll" "LUA_T=lua.exe" \
 -	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
 -	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
 +	$(MAKE) "LUA_T=lua.exe" \

python_lua_helper-1.4.0/lua/lua-5.5.0.sha256

@@ -0,0 +1 @@
+57ccc32bbbd005cab75bcc52444052535af691789dba2b9016d5c50640d68b3d *lua-5.5.0.tar.gz

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/python_lua_helper/loader.lua

@@ -242,19 +242,36 @@ if loader.postexec ~= nil then
  dofile(loader.postexec)
 end
 
-loader.dataout=loader.tmpdir..loader.pathseparator.."data"..loader.pathseparator
-loader.metaout=loader.tmpdir..loader.pathseparator.."meta"..loader.pathseparator
+loader.dataout=loader.tmpdir..loader.pathseparator.."data.tmp"
+loader.metaout=loader.tmpdir..loader.pathseparator.."meta.tmp"
+loader.indexout=loader.tmpdir..loader.pathseparator.."index.tmp"
+
+target_data = assert(io.open(loader.dataout, "w"))
+target_meta = assert(io.open(loader.metaout, "w"))
+target_index = assert(io.open(loader.indexout, "w"))
+
+target_data:write("start")
+target_data:write("\255".."\000")
+
+target_meta:write("start")
+target_meta:write("\255".."\000")
+
+target_index:write("start")
+target_index:write("\255".."\000")
 
 function loader_data_export(name,value)
- local target = assert(io.open(loader.dataout..name, "w"))
- target:write(string.format("%s",tostring(value)))
- target:close()
+ -- write value to target_data
+ target_data:write(string.format("%s",tostring(value)))
+ target_data:write("\255".."\000")
 end
 
 function loader_meta_export(name,value)
- local target = assert(io.open(loader.metaout..name, "w"))
- target:write(string.format("%s",tostring(value)))
- target:close()
+ -- write name to target_index
+ target_index:write(name)
+ target_index:write("\255".."\000")
+ -- write value to target_meta
+ target_meta:write(string.format("%s",tostring(value)))
+ target_meta:write("\255".."\000")
 end
 
 function loader_node_export(name,node)
@@ -309,3 +326,7 @@ for index,value in ipairs(loader.export) do
     loader_node_export(value,target)
   end
 end
+
+target_index:close()
+target_meta:close()
+target_data:close()

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/python_lua_helper/py_lua_helper.py

@@ -45,53 +45,47 @@ class PyLuaHelper:
             lua_binary: Path to specific Lua binary (optional, will be auto-detected if not provided)
             lua_args: Additional arguments to pass to Lua script (will be placed to loader.args)
         """
-        self.lua_config_script = os.path.abspath(lua_config_script)
-        self.export_vars = export_vars or []
-        self.pre_script = pre_script
-        self.post_script = post_script
-        self.extra_strings = extra_strings or []
-        self.work_dir = work_dir or os.path.dirname(self.lua_config_script)
-        self.temp_dir = temp_dir
-        self.min_lua_version = min_lua_version or "5.1.0"
-        self.max_lua_version = max_lua_version or "5.4.999"
-        self.lua_binary = lua_binary
-        self.lua_args = lua_args or []
-        self.lua_actual_version = None
-
+        self._lua_config_script = os.path.abspath(lua_config_script)
+        self._export_vars = export_vars or []
+        self._pre_script = pre_script
+        self._post_script = post_script
+        self._extra_strings = extra_strings or []
+        self._work_dir = work_dir or os.path.dirname(self._lua_config_script)
+        self._temp_dir = temp_dir
+        self._min_lua_version = min_lua_version or "5.1.0"
+        self._max_lua_version = max_lua_version or "5.5.999"
+        self._lua_binary = lua_binary
+        self._lua_args = lua_args or []
+        self._lua_actual_version = None
         # Validate required files exist
-        if not os.path.exists(self.lua_config_script):
+        if not os.path.exists(self._lua_config_script):
             raise FileNotFoundError(
-                f"Main config file not found: {self.lua_config_script}"
+                f"Main config file not found: {self._lua_config_script}"
             )
-
         # Initialize internal state
         self._variables: Dict[str, str] = {}
         self._metadata: Dict[str, str] = {}
-        self._export_list: List[str] = []
-
         # Initialize temporary directory
         self._setup_temp_dir()
-
-        # Detect Lua binary
-        if not self.lua_binary:
-            self._detect_lua_binary()
-
-        # Execute the Lua loader
-        self._run_lua_loader()
-
-        # Parse results
-        self._parse_results()
-
-        # Clean up temp directory
-        self._cleanup()
+        try:
+            # Detect Lua binary
+            if not self._lua_binary:
+                self._detect_lua_binary()
+            # Execute the Lua loader
+            self._run_lua_loader()
+            # Parse results
+            self._parse_results()
+        finally:
+            # Clean up temp directory
+            self._cleanup()
 
     def _setup_temp_dir(self):
         """Setup temporary directory for storing exported variables."""
-        if self.temp_dir:
-            if not os.path.exists(self.temp_dir):
-                raise ValueError(f"Temp directory does not exist: {self.temp_dir}")
-            self.temp_dir = os.path.abspath(self.temp_dir)
-            self.temp_dir = tempfile.mkdtemp(prefix="lua-helper-", dir=self.temp_dir)
+        if self._temp_dir:
+            if not os.path.exists(self._temp_dir):
+                raise ValueError(f"Temp directory does not exist: {self._temp_dir}")
+            self._temp_dir = os.path.abspath(self._temp_dir)
+            self._temp_dir = tempfile.mkdtemp(prefix="lua-helper-", dir=self._temp_dir)
         else:
             # Detect temp directory if not provided, platform dependent
             if os.name == "nt":  # Windows
@@ -109,7 +103,7 @@ class PyLuaHelper:
                 for base_dir in temp_dirs:
                     try:
                         # Try to create temp directory in this location
-                        self.temp_dir = tempfile.mkdtemp(
+                        self._temp_dir = tempfile.mkdtemp(
                             prefix="lua-helper-", dir=base_dir
                         )
                         break
@@ -141,34 +135,33 @@ class PyLuaHelper:
                                 text=True,
                             )
                             if result.returncode == 0:
-                                self.temp_dir = target
+                                self._temp_dir = target
                                 break
                         except Exception:
                             continue
-                if not self.temp_dir:
-                    self.temp_dir = "/tmp"
+                if not self._temp_dir:
+                    self._temp_dir = "/tmp"
                 # Create unique temp directory
-                self.temp_dir = tempfile.mkdtemp(
-                    prefix="lua-helper-", dir=self.temp_dir
+                self._temp_dir = tempfile.mkdtemp(
+                    prefix="lua-helper-", dir=self._temp_dir
                 )
-        # Create data storage directories in selected temp dir
-        self.meta_dir = os.path.join(self.temp_dir, "meta")
-        self.data_dir = os.path.join(self.temp_dir, "data")
-        os.makedirs(self.meta_dir)
-        os.makedirs(self.data_dir)
+        # Define temp files for data exchange
+        self._meta_file = os.path.join(self._temp_dir, "meta.tmp")
+        self._data_file = os.path.join(self._temp_dir, "data.tmp")
+        self._index_file = os.path.join(self._temp_dir, "index.tmp")
 
     def _detect_lua_binary(self):
         """Detect appropriate Lua binary based on version requirements."""
-        if self.lua_binary:
+        if self._lua_binary:
             # Use explicitly provided binary
-            if not os.path.exists(self.lua_binary):
-                raise FileNotFoundError(f"Lua binary not found: {self.lua_binary}")
-            if self._validate_lua_version(self.lua_binary):
-                self.lua_binary = os.path.abspath(self.lua_binary)
+            if not os.path.exists(self._lua_binary):
+                raise FileNotFoundError(f"Lua binary not found: {self._lua_binary}")
+            if self._validate_lua_version(self._lua_binary):
+                self._lua_binary = os.path.abspath(self._lua_binary)
                 return
             else:
                 raise ValueError(
-                    f"Lua binary does not meet version requirements: {self.lua_binary}"
+                    f"Lua binary does not meet version requirements: {self._lua_binary}"
                 )
         # Probe for available Lua binaries
         lua_hints = [
@@ -190,7 +183,7 @@ class PyLuaHelper:
             try:
                 lua_path = shutil.which(f"{hint}{bin_suffix}")
                 if lua_path and self._validate_lua_version(lua_path):
-                    self.lua_binary = os.path.abspath(lua_path)
+                    self._lua_binary = os.path.abspath(lua_path)
                     return
             except Exception:
                 continue
@@ -207,20 +200,17 @@ class PyLuaHelper:
             )
             if not version_match:
                 return False
-
             act_version = [int(x) for x in version_match.groups()]
-            min_version = [int(x) for x in self.min_lua_version.split(".")]
-            max_version = [int(x) for x in self.max_lua_version.split(".")]
-
+            min_version = [int(x) for x in self._min_lua_version.split(".")]
+            max_version = [int(x) for x in self._max_lua_version.split(".")]
             # Check version range
             for i, (act, min_v, max_v) in enumerate(
                 zip(act_version, min_version, max_version)
             ):
                 if not (min_v <= act <= max_v):
                     return False
-
             # Store the actual version if validation passes
-            self.lua_actual_version = act_version
+            self._lua_actual_version = act_version
             return True
         except Exception:
             return False
@@ -228,49 +218,38 @@ class PyLuaHelper:
     def _run_lua_loader(self):
         """Execute the Lua loader script with appropriate parameters."""
         # Build command line arguments
-        cmd = [self.lua_binary, os.path.join(os.path.dirname(__file__), "loader.lua")]
-
+        cmd = [self._lua_binary, os.path.join(os.path.dirname(__file__), "loader.lua")]
         # Add version info
         cmd.extend(
             [
                 "-ver",
-                str(self.lua_actual_version[0]),
-                str(self.lua_actual_version[1]),
-                str(self.lua_actual_version[2]),
+                str(self._lua_actual_version[0]),
+                str(self._lua_actual_version[1]),
+                str(self._lua_actual_version[2]),
             ]
         )
-
         # Add configuration parameters
-        cmd.extend(["-c", self.lua_config_script])
-
+        cmd.extend(["-c", self._lua_config_script])
         # Add export variables
-        for var in self.export_vars:
+        for var in self._export_vars:
             cmd.extend(["-e", var])
-
         # Add pre script
-        if self.pre_script:
-            cmd.extend(["-pre", self.pre_script])
-
+        if self._pre_script:
+            cmd.extend(["-pre", self._pre_script])
         # Add post script
-        if self.post_script:
-            cmd.extend(["-post", self.post_script])
-
+        if self._post_script:
+            cmd.extend(["-post", self._post_script])
         # Add extra strings
-        for extra in self.extra_strings:
+        for extra in self._extra_strings:
             cmd.extend(["-ext", extra])
-
         # Add work directory
-        cmd.extend(["-w", self.work_dir])
-
+        cmd.extend(["-w", self._work_dir])
         # Add temp directory
-        cmd.extend(["-t", self.temp_dir])
-
+        cmd.extend(["-t", self._temp_dir])
         # Add -- separator
         cmd.append("--")
-
         # Add additional Lua arguments
-        cmd.extend(self.lua_args)
-
+        cmd.extend(self._lua_args)
         # Execute the command
         try:
             result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
@@ -283,34 +262,61 @@ class PyLuaHelper:
         except subprocess.TimeoutExpired:
             raise RuntimeError("Lua loader timed out")
 
-    def _parse_results(self):
-        """Parse exported variables from temporary files."""
-        # Read the list of exported variables
-        try:
-            self._export_list = os.listdir(self.data_dir)
-        except Exception:
-            self._export_list = []
+    def _parse_text_fields(self, file_path: str):
+        """
+        Parses a binary file containing UTF-8 text fields generated by loader.lua
 
-        # Load each variable
-        for filename in self._export_list:
-            try:
-                # Read data
-                with open(os.path.join(self.data_dir, filename), "rb") as f:
-                    self._variables[filename] = f.read().decode(
-                        "utf-8", errors="ignore"
+        Args:
+            file_path (str): The path to the binary file.
+
+        Returns:
+            list: A list of strings containing the parsed UTF-8 fields.
+        """
+        fields = []
+        with open(file_path, "rb") as f:
+            file_content = f.read()
+        # Locate the start marker, set initial position
+        header_marker = b"start\xff\x00"
+        start_pos = file_content.find(header_marker)
+        if start_pos == -1:
+            raise ValueError(f"Failed to locate start marker at {file_path}")
+        current_pos = start_pos + len(header_marker)
+        # Read UTF8 text fields, separated with special sequence
+        separator = b"\xff\x00"
+        while True:
+            # Find the next separator
+            sep_pos = file_content.find(separator, current_pos)
+            if sep_pos != -1:
+                # Extract the bytes for the current field
+                field_bytes = file_content[current_pos:sep_pos]
+                field_str = field_bytes.decode("utf-8")
+                fields.append(field_str)
+                # Move pointer past the separator
+                current_pos = sep_pos + len(separator)
+            else:
+                # No separator found, this is the last field (no terminator at the end)
+                if current_pos < len(file_content):
+                    raise ValueError(
+                        f"Surplus data at the end of file, at pos: {current_pos}"
                     )
-                # Read metadata
-                with open(os.path.join(self.meta_dir, filename), "rb") as f:
-                    self._metadata[filename] = f.read().decode("utf-8", errors="ignore")
-            except Exception:
-                # Skip problematic files
-                continue
+                break
+        return fields
+
+    def _parse_results(self):
+        """Parse exported variables from temporary files."""
+        # Read exported data
+        exports = self._parse_text_fields(self._index_file)
+        meta = self._parse_text_fields(self._meta_file)
+        data = self._parse_text_fields(self._data_file)
+        for index, value in enumerate(exports):
+            self._variables[value] = data[index]
+            self._metadata[value] = meta[index]
 
     def _cleanup(self):
         """Clean up temporary directory."""
-        if self.temp_dir and os.path.exists(self.temp_dir):
+        if self._temp_dir and os.path.exists(self._temp_dir):
             try:
-                shutil.rmtree(self.temp_dir)
+                shutil.rmtree(self._temp_dir)
             except Exception:
                 pass
 
@@ -394,7 +400,12 @@ class PyLuaHelper:
         try:
             value_type = self.get_type(key)
             if value_type == "boolean":
-                return bool(self._variables.get(key, default))
+                value = self._variables.get(key)
+                if value == "true":
+                    value = True
+                elif value == "false":
+                    value = False
+                return bool(value)
             raise ValueError(f"Invalid value type: {value_type}")
         except ValueError:
             if default is not None:

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/python_lua_helper/test_example/example.cfg.lua

@@ -27,7 +27,7 @@ config =
 		mixed={ 1, "text", true, key="test_value" },
 		empty_table={ },
 		types = {
-			b=true,
+			b=false,
 			i=100,
 			f=99.99,
 			s="string value",

{python_lua_helper-1.2.0 → python_lua_helper-1.4.0}/python_lua_helper/test_example.py

@@ -147,7 +147,7 @@ print(f"example.py: {cfg.get_list('config.sub.loader_args')}")
 # Test typed get
 print("example.py: === test getting values with specific type from config.sub.types table ===")
 print(f"example.py: get bool value, no fallback: cfg['config.sub.types.b'] = {cfg.get_bool('config.sub.types.b')}")
-print(f"example.py: get missing bool value, fallback: cfg['config.sub.types.b1'] = {cfg.get_bool('config.sub.types.b1', False)}")
+print(f"example.py: get missing bool value, fallback: cfg['config.sub.types.b1'] = {cfg.get_bool('config.sub.types.b1', True)}")
 print(f"example.py: get bool value from int, fallback: cfg['config.sub.types.i'] = {cfg.get_bool('config.sub.types.i', False)}")
 
 print(f"example.py: get int value, no fallback: cfg['config.sub.types.i'] = {cfg.get_int('config.sub.types.i')}")

python_lua_helper-1.2.0/lua/lua-5.4.8.sha256

@@ -1 +0,0 @@
-4f18ddae154e793e46eeab727c59ef1c0c0c2b744e7b94219710d76f530629ae *lua-5.4.8.tar.gz