varfile 0.1.0__py3-none-any.whl

varfile/__init__.py

@@ -0,0 +1,3 @@
+from .parser import load, loads, dump, dumps, VarConfig
+
+__all__ = ['load', 'loads', 'dump', 'dumps', 'VarConfig']

varfile/parser.py

@@ -0,0 +1,140 @@
+import os
+
+class VarConfig(dict):
+    """A dictionary subclass that allows dot-notation access (e.g., config.Database.host)."""
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # Recursively convert nested dictionaries into VarConfig objects
+        for k, v in self.items():
+            if isinstance(v, dict) and not isinstance(v, VarConfig):
+                self[k] = VarConfig(v)
+                
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"'VarConfig' object has no attribute '{key}'")
+
+    def __setattr__(self, key, value):
+        if isinstance(value, dict) and not isinstance(value, VarConfig):
+            value = VarConfig(value)
+        self[key] = value
+
+
+def _strip_comment(line: str) -> str:
+    """Strips trailing comments while ignoring '#' characters inside quotes."""
+    in_quote = False
+    quote_char = None
+    
+    for i, char in enumerate(line):
+        if char in ('"', "'"):
+            if not in_quote:
+                in_quote = True
+                quote_char = char
+            elif char == quote_char:
+                in_quote = False
+                quote_char = None
+        elif char == '#' and not in_quote:
+            return line[:i]  # Return everything before the comment
+    return line
+
+
+def _parse_value(val: str):
+    """Converts text values into native Python types."""
+    val = val.strip()
+    
+    # Handle Strings
+    if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+        return val[1:-1]
+    
+    # Handle Booleans
+    if val.lower() == 'true':
+        return True
+    if val.lower() == 'false':
+        return False
+    
+    # Handle Numbers
+    try:
+        if '.' in val:
+            return float(val)
+        return int(val)
+    except ValueError:
+        pass
+
+    return val
+
+
+def _format_value(val) -> str:
+    """Formats a Python type back into a .var valid string syntax."""
+    if isinstance(val, bool):
+        return "true" if val else "false"
+    if isinstance(val, str):
+        return f'"{val}"'
+    return str(val)
+
+
+# --- READ FUNCTIONS ---
+
+def loads(content: str) -> VarConfig:
+    """Parses a string of .var data into a VarConfig object."""
+    data = {}
+    current_context = data
+
+    for line in content.splitlines():
+        line = _strip_comment(line).strip()
+        if not line:
+            continue
+        
+        # Handle Classes / Sections
+        if line.startswith('[') and line.endswith(']'):
+            class_name = line[1:-1].strip()
+            data[class_name] = {}
+            current_context = data[class_name]
+            continue
+        
+        # Handle Key = Value
+        if '=' in line:
+            key, val = line.split('=', 1)
+            current_context[key.strip()] = _parse_value(val)
+            
+    return VarConfig(data)
+
+
+def load(filepath: str) -> VarConfig:
+    """Reads a .var file and parses it into a VarConfig object."""
+    if not os.path.exists(filepath):
+        raise FileNotFoundError(f"The file {filepath} does not exist.")
+        
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return loads(f.read())
+
+
+# --- WRITE FUNCTIONS ---
+
+def dumps(data: dict) -> str:
+    """Serializes a dictionary/VarConfig back into a .var string format."""
+    lines = []
+    sections = {}
+    
+    # Separate top-level variables and sub-classes
+    for k, v in data.items():
+        if isinstance(v, dict):
+            sections[k] = v
+        else:
+            lines.append(f"{k} = {_format_value(v)}")
+            
+    # Format sub-classes
+    for section_name, section_data in sections.items():
+        if lines:  # Add an empty line separation between sections
+            lines.append("")
+        lines.append(f"[{section_name}]")
+        for k, v in section_data.items():
+            lines.append(f"{k} = {_format_value(v)}")
+            
+    return "\n".join(lines)
+
+
+def dump(data: dict, filepath: str):
+    """Writes a dictionary/VarConfig into a physical .var file."""
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(dumps(data))

varfile-0.1.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: varfile
+Version: 0.1.0
+Summary: A simple parser for .var variable files with object-mapping support
+Author: Ely
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# varfile
+
+**varfile** is a fast, lightweight, zero-dependency Python library for working with `.var` configuration files. It combines the simplicity of INI-style configs with Python-friendly object access, automatic type conversion, and easy file editing.
+
+## Features
+
+* **Dot Notation Access**
+  Access configuration values naturally:
+
+  ```python
+  config.Database.host
+  ```
+
+  instead of:
+
+  ```python
+  config["Database"]["host"]
+  ```
+
+* **Automatic Type Conversion**
+  Values are automatically converted to the appropriate Python types:
+
+  * `int`
+  * `float`
+  * `bool`
+  * `str`
+
+* **Easy Editing**
+  Modify values directly in memory and save them back to disk with a single command.
+
+* **Robust Parsing**
+  Handles comments, special characters, URLs containing `#`, and other common edge cases.
+
+* **Clean Serialization**
+  Preserves formatting conventions such as lowercase booleans (`true` / `false`) when writing files.
+
+---
+
+# Installation
+
+Install with pip:
+
+```bash
+pip install varfile
+```
+
+Or with uv:
+
+```bash
+uv add varfile
+```
+
+---
+
+# Quick Start
+
+## 1. Create a `.var` File
+
+Create a file named `demo.var`:
+
+```ini
+# Global settings
+app_name = "Varfile Demo"
+environment = "development"
+debug_mode = true
+max_users = 150
+
+[Database]
+host = "127.0.0.1"
+port = 5432
+timeout = 45.8
+enabled = false
+url = "https://varfiletest.com/#user1"
+```
+
+---
+
+## 2. Read Configuration Values
+
+Load a file and access values using dot notation:
+
+```python
+import varfile
+
+config = varfile.load("demo.var")
+
+print(config.app_name)          # Varfile Demo
+print(config.max_users)         # 150
+print(config.Database.port)     # 5432
+print(config.Database.enabled)  # False
+```
+
+---
+
+## 3. Modify and Save Values
+
+Update values in memory and write them back to the file:
+
+```python
+import varfile
+
+config = varfile.load("demo.var")
+
+config.max_users = 100
+config.Database.port = 5000
+
+varfile.dump(config, "demo.var")
+
+print("Configuration updated successfully!")
+```
+
+---
+
+## 4. Create a Configuration From Scratch
+
+You can also build configuration files programmatically:
+
+```python
+import varfile
+
+config = varfile.VarConfig()
+
+config.new_setting = "Hello World"
+config.user_count = 1
+
+config.FeatureToggle = {
+    "dark_mode": True,
+    "beta_tester": False
+}
+
+varfile.dump(config, "new_config.var")
+```
+
+Generated `new_config.var`:
+
+```ini
+new_setting = "Hello World"
+user_count = 1
+
+[FeatureToggle]
+dark_mode = true
+beta_tester = false
+```
+
+---
+
+# API Reference
+
+| Function / Class                 | Description                                                           |
+| -------------------------------- | --------------------------------------------------------------------- |
+| `varfile.load(filepath)`         | Load a `.var` file from disk and return a `VarConfig` object.         |
+| `varfile.dump(config, filepath)` | Save a `VarConfig` object to a `.var` file.                           |
+| `varfile.loads(string_data)`     | Parse `.var` content from a string.                                   |
+| `varfile.dumps(config)`          | Convert a configuration object into `.var` formatted text.            |
+| `varfile.VarConfig()`            | Create a new empty configuration container with dot notation support. |
+
+---
+
+# Why varfile?
+
+Many configuration formats are either too limited or unnecessarily complex. varfile aims to provide a middle ground:
+
+* Easy to read
+* Easy to edit
+* Python-friendly
+* No external dependencies
+* Clean object-style access
+
+Whether you're building a small script or a larger application, varfile keeps configuration management simple.

varfile-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+varfile/__init__.py,sha256=8Q-aFP_qCzNTSRJ4X9MmyXna0L65slAhAwzfunAdGbs,116
+varfile/parser.py,sha256=ylNHD7DR20xVB9e9uIfABoidFaOATdjZEJIwpZ3n7dk,4296
+varfile-0.1.0.dist-info/METADATA,sha256=-tkQEUfNZHh2E6eu2k4EIinoQa0da9OaiKO1GsJwTvY,3970
+varfile-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+varfile-0.1.0.dist-info/top_level.txt,sha256=R1gipGfCDtqh9SPJOllm4PJb5BGcrWONpLLndHONxUs,8
+varfile-0.1.0.dist-info/RECORD,,

varfile-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

varfile-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+varfile