dan-annotation 0.1.0__tar.gz

dan_annotation-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 DAN Python Library Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dan_annotation-0.1.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: dan-annotation
+Version: 0.1.0
+Summary: DAN (Data Advanced Notation) Parser and Encoder for Python
+Author: DAN Python Library
+License-Expression: MIT
+Project-URL: Documentation, https://github.com/marcuwynu23/danpy#readme
+Project-URL: Issue Tracker, https://github.com/marcuwynu23/danpy/issues
+Project-URL: Source Code, https://github.com/marcuwynu23/danpy
+Keywords: dan,parser,encoder,data-format,configuration,config
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# DAN (Data Advanced Notation) Python Library
+
+[![Python Version](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+A Python implementation of the DAN (Data Advanced Notation) parser and encoder. DAN is a human-readable data format that combines the simplicity of key-value pairs with the power of nested structures and tables.
+
+## Features
+
+- **Decode**: Parse DAN text into Python dictionaries
+- **Encode**: Convert Python dictionaries into DAN text
+- Support for nested blocks, tables, arrays, and various data types
+- Comment support (# and //)
+- Type inference (strings, numbers, booleans, arrays)
+- Comprehensive test suite with 40+ test cases
+- Multiple real-world examples
+
+See [FEATURES.md](FEATURES.md) for a complete feature list.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/dan-py.git
+cd dan-py
+pip install -e .
+```
+
+## Quick Start
+
+### Decoding DAN
+
+```python
+from dan import decode
+
+text = """
+app {
+  name: "MyApp"
+  version: 1.0
+  server {
+    host: localhost
+    port: 3000
+  }
+}
+"""
+
+data = decode(text)
+print(data)
+# {'app': {'name': 'MyApp', 'version': 1.0, 'server': {'host': 'localhost', 'port': 3000}}}
+```
+
+### Encoding to DAN
+
+```python
+from dan import encode
+
+data = {
+    "app": {
+        "name": "MyApp",
+        "version": 1.0,
+        "server": {
+            "host": "localhost",
+            "port": 3000
+        }
+    }
+}
+
+text = encode(data)
+print(text)
+```
+
+### Working with Tables
+
+```python
+text = """
+users: table(id, username, email) [
+  1, alice, "alice@example.com"
+  2, bob, "bob@example.com"
+]
+"""
+
+data = decode(text)
+# {'users': [{'id': 1, 'username': 'alice', 'email': 'alice@example.com'}, ...]}
+```
+
+### Reading from Files
+
+```python
+from dan import decode
+
+with open('config.dan', 'r') as f:
+    config = decode(f.read())
+```
+
+## Examples
+
+Check out the [examples/](examples/) directory for real-world usage scenarios:
+
+- Application configuration (`config.dan`)
+- Database schemas (`database_schema.dan`)
+- API routes (`api_routes.dan`)
+- Microservices configuration (`microservices.dan`)
+- Docker Compose (`docker_compose.dan`)
+- Kubernetes resources (`kubernetes.dan`)
+- And many more!
+
+## Running Tests
+
+```bash
+# Run all tests
+python -m unittest discover tests -v
+
+# Run specific test file
+python -m unittest tests.test_dan -v
+
+# Using pytest (if installed)
+pytest tests/
+```
+
+## Documentation
+
+- [FEATURES.md](FEATURES.md) - Complete feature documentation
+- [CONTRIBUTING.md](CONTRIBUTING.md) - Guidelines for contributing
+- [CHANGELOG.md](CHANGELOG.md) - Version history and changes
+- [examples/README.md](examples/README.md) - Example files documentation
+
+## Contributing
+
+Contributions are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Security
+
+Please report security vulnerabilities to the maintainers. See [SECURITY.md](SECURITY.md) for more information.
+
+## Support
+
+- 📖 [Documentation](https://github.com/yourusername/dan-py#readme)
+- 🐛 [Issue Tracker](https://github.com/yourusername/dan-py/issues)
+- 💬 [Discussions](https://github.com/yourusername/dan-py/discussions)
+

dan_annotation-0.1.0/README.md

@@ -0,0 +1,149 @@
+# DAN (Data Advanced Notation) Python Library
+
+[![Python Version](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+A Python implementation of the DAN (Data Advanced Notation) parser and encoder. DAN is a human-readable data format that combines the simplicity of key-value pairs with the power of nested structures and tables.
+
+## Features
+
+- **Decode**: Parse DAN text into Python dictionaries
+- **Encode**: Convert Python dictionaries into DAN text
+- Support for nested blocks, tables, arrays, and various data types
+- Comment support (# and //)
+- Type inference (strings, numbers, booleans, arrays)
+- Comprehensive test suite with 40+ test cases
+- Multiple real-world examples
+
+See [FEATURES.md](FEATURES.md) for a complete feature list.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/yourusername/dan-py.git
+cd dan-py
+pip install -e .
+```
+
+## Quick Start
+
+### Decoding DAN
+
+```python
+from dan import decode
+
+text = """
+app {
+  name: "MyApp"
+  version: 1.0
+  server {
+    host: localhost
+    port: 3000
+  }
+}
+"""
+
+data = decode(text)
+print(data)
+# {'app': {'name': 'MyApp', 'version': 1.0, 'server': {'host': 'localhost', 'port': 3000}}}
+```
+
+### Encoding to DAN
+
+```python
+from dan import encode
+
+data = {
+    "app": {
+        "name": "MyApp",
+        "version": 1.0,
+        "server": {
+            "host": "localhost",
+            "port": 3000
+        }
+    }
+}
+
+text = encode(data)
+print(text)
+```
+
+### Working with Tables
+
+```python
+text = """
+users: table(id, username, email) [
+  1, alice, "alice@example.com"
+  2, bob, "bob@example.com"
+]
+"""
+
+data = decode(text)
+# {'users': [{'id': 1, 'username': 'alice', 'email': 'alice@example.com'}, ...]}
+```
+
+### Reading from Files
+
+```python
+from dan import decode
+
+with open('config.dan', 'r') as f:
+    config = decode(f.read())
+```
+
+## Examples
+
+Check out the [examples/](examples/) directory for real-world usage scenarios:
+
+- Application configuration (`config.dan`)
+- Database schemas (`database_schema.dan`)
+- API routes (`api_routes.dan`)
+- Microservices configuration (`microservices.dan`)
+- Docker Compose (`docker_compose.dan`)
+- Kubernetes resources (`kubernetes.dan`)
+- And many more!
+
+## Running Tests
+
+```bash
+# Run all tests
+python -m unittest discover tests -v
+
+# Run specific test file
+python -m unittest tests.test_dan -v
+
+# Using pytest (if installed)
+pytest tests/
+```
+
+## Documentation
+
+- [FEATURES.md](FEATURES.md) - Complete feature documentation
+- [CONTRIBUTING.md](CONTRIBUTING.md) - Guidelines for contributing
+- [CHANGELOG.md](CHANGELOG.md) - Version history and changes
+- [examples/README.md](examples/README.md) - Example files documentation
+
+## Contributing
+
+Contributions are welcome! Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Security
+
+Please report security vulnerabilities to the maintainers. See [SECURITY.md](SECURITY.md) for more information.
+
+## Support
+
+- 📖 [Documentation](https://github.com/yourusername/dan-py#readme)
+- 🐛 [Issue Tracker](https://github.com/yourusername/dan-py/issues)
+- 💬 [Discussions](https://github.com/yourusername/dan-py/discussions)
+

dan_annotation-0.1.0/dan.py

@@ -0,0 +1,221 @@
+"""
+DAN (Data Advanced Notation) Parser and Encoder for Python
+"""
+
+import re
+from typing import Any, Dict, List, Union
+
+
+def decode(text: Union[str, bytes]) -> Dict[str, Any]:
+    """
+    Decode DAN text into a Python dictionary.
+    
+    Args:
+        text: DAN text as string or bytes
+        
+    Returns:
+        Dictionary representation of the DAN data
+        
+    Raises:
+        TypeError: If input is not string or bytes
+    """
+    # Handle bytes inputs
+    if isinstance(text, bytes):
+        text = text.decode('utf-8')
+    
+    # Ensure text is a string
+    if not isinstance(text, str):
+        raise TypeError(f"Expected string or bytes, got {type(text).__name__}")
+    
+    # Handle empty input - return empty object
+    if not text or not text.strip():
+        return {}
+    
+    lines = text.splitlines()
+    stack = [{"obj": {}, "type": "root"}]
+    current_table = None
+    
+    table_re = re.compile(r'^(\w+):\s*table\(([^)]+)\)\s*\[$')
+    kv_re = re.compile(r'^(\w+):\s*(.+)$')
+    
+    for i, line in enumerate(lines):
+        # Remove comments and trim
+        comment_index1 = line.find("#")
+        comment_index2 = line.find("//")
+        cut_index = -1
+        if comment_index1 >= 0 and comment_index2 >= 0:
+            cut_index = min(comment_index1, comment_index2)
+        else:
+            cut_index = max(comment_index1, comment_index2)
+        
+        if cut_index >= 0:
+            line = line[:cut_index]
+        line = line.strip()
+        if not line:
+            continue
+        
+        top = stack[-1]
+        
+        # Block start
+        if line.endswith("{"):
+            key = line[:-1].strip()
+            new_obj = {}
+            top["obj"][key] = new_obj
+            stack.append({"obj": new_obj, "type": "block"})
+            continue
+        
+        # Block end
+        if line == "}":
+            stack.pop()
+            continue
+        
+        # Table start
+        table_match = table_re.match(line)
+        if table_match:
+            key = table_match.group(1)
+            columns = [c.strip() for c in table_match.group(2).split(",")]
+            table = []
+            top["obj"][key] = table
+            current_table = {"obj": table, "columns": columns}
+            continue
+        
+        # Table end
+        if line == "]":
+            current_table = None
+            continue
+        
+        # Table row
+        if current_table:
+            row = {}
+            # Split by comma and trim each value
+            values = [v.strip() for v in line.split(",")]
+            # Only process up to the number of columns defined
+            for col_idx, val in enumerate(values):
+                if col_idx < len(current_table["columns"]):
+                    row[current_table["columns"][col_idx]] = parse_value(val)
+            # Ensure all columns are present (fill missing with empty string)
+            for col_idx, col_name in enumerate(current_table["columns"]):
+                if col_name not in row:
+                    row[col_name] = ""
+            current_table["obj"].append(row)
+            continue
+        
+        # Key-value
+        kv_match = kv_re.match(line)
+        if kv_match:
+            key = kv_match.group(1)
+            val = kv_match.group(2)
+            top["obj"][key] = parse_value(val)
+    
+    return stack[0]["obj"]
+
+
+def encode(obj: Dict[str, Any], indent: int = 0) -> str:
+    """
+    Encode a Python dictionary into DAN text.
+    
+    Args:
+        obj: Dictionary to encode
+        indent: Current indentation level (for recursion)
+        
+    Returns:
+        DAN text representation
+    """
+    lines = []
+    pad = "  " * indent
+    
+    for key, val in obj.items():
+        if isinstance(val, list):
+            if len(val) > 0 and isinstance(val[0], dict) and not isinstance(val[0], list):
+                # Table
+                columns = list(val[0].keys())
+                lines.append(f"{pad}{key}: table({', '.join(columns)}) [")
+                for row in val:
+                    row_values = [serialize_value(row.get(c)) for c in columns]
+                    lines.append(f"{pad}  {', '.join(row_values)}")
+                lines.append(f"{pad}]")
+            else:
+                lines.append(f"{pad}{key}: {serialize_value(val)}")
+        elif isinstance(val, dict):
+            lines.append(f"{pad}{key} {{")
+            nested_lines = encode(val, indent + 1)
+            if nested_lines:
+                # Split nested lines and add them individually for proper formatting
+                nested_lines_array = nested_lines.split("\n")
+                lines.extend(nested_lines_array)
+            lines.append(f"{pad}}}")
+        else:
+            lines.append(f"{pad}{key}: {serialize_value(val)}")
+    
+    return "\n".join(lines)
+
+
+# --- Internal helpers ---
+
+def parse_value(val: str) -> Any:
+    """
+    Parse a string value into appropriate Python type.
+    
+    Args:
+        val: String value to parse
+        
+    Returns:
+        Parsed value (bool, int, float, str, list, or original string)
+    """
+    if not isinstance(val, str):
+        return val
+    
+    val = val.strip()
+    
+    if val == "true":
+        return True
+    if val == "false":
+        return False
+    
+    # String (quoted)
+    if len(val) >= 2 and val[0] == '"' and val[-1] == '"':
+        return val[1:-1]
+    
+    # Number
+    if val and not val.startswith("["):
+        try:
+            # Try integer first
+            if '.' not in val:
+                return int(val)
+            else:
+                return float(val)
+        except ValueError:
+            pass
+    
+    # Array
+    if len(val) >= 2 and val[0] == "[" and val[-1] == "]":
+        content = val[1:-1].strip()
+        if content == "":
+            return []
+        # Split by comma, but preserve empty strings for explicit empty values
+        parts = [v.strip() for v in content.split(",")]
+        return [parse_value(v) for v in parts]
+    
+    return val
+
+
+def serialize_value(val: Any) -> str:
+    """
+    Serialize a Python value to DAN string representation.
+    
+    Args:
+        val: Value to serialize
+        
+    Returns:
+        String representation
+    """
+    if isinstance(val, bool):
+        return "true" if val else "false"
+    if isinstance(val, str):
+        return f'"{val}"'
+    if isinstance(val, (int, float)):
+        return str(val)
+    if isinstance(val, list):
+        return f"[{', '.join(serialize_value(v) for v in val)}]"
+    return str(val)
+