Update .zon references to .zonf and bump version to 1.2.1

Co-authored-by: ronibhakta1 <77425964+ronibhakta1@users.noreply.github.com>

Author: Copilot

zon-format/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zon-format"
-version = "1.2.0"
-description = "Zero Overhead Notation v1.2.0 - Human-readable data format with 30%+ compression over JSON, now with adaptive encoding"
+version = "1.2.1"
+description = "Zero Overhead Notation v1.2.1 - Human-readable data format with 30%+ compression over JSON, now with adaptive encoding"
 readme = "README.md"
 requires-python = ">=3.8"
 license = {text = "MIT"}

zon-format/src/zon/integrations/langchain.py

@@ -56,7 +56,7 @@ def parse(self, text: str) -> Any:
             ValueError: If parsing fails
         """
         try:
-            cleaned = re.sub(r'```(zon|zonf)?', '', text).strip()
+            cleaned = re.sub(r'```zonf?', '', text).strip()
             cleaned = cleaned.replace('```', '').strip()
             return decode(cleaned)
         except Exception as e:

zon-format/src/zon/integrations/openai.py

@@ -71,7 +71,7 @@ def chat(self, **kwargs) -> Any:
         response = self.client.chat.completions.create(**kwargs)
         content = response.choices[0].message.content or ''
 
-        cleaned = re.sub(r'```(zon|zonf)?', '', content).strip()
+        cleaned = re.sub(r'```zonf?', '', content).strip()
         cleaned = cleaned.replace('```', '').strip()
 
         return decode(cleaned)

zon-format/src/zon/tools/helpers.py

@@ -10,24 +10,24 @@
 from ..binary import encode_binary
 
 
-def size(data: Any, format: Literal['zon', 'binary', 'json'] = 'zon') -> int:
+def size(data: Any, format: Literal['zonf', 'binary', 'json'] = 'zonf') -> int:
     """Calculate the encoded size of data in different formats.
     
     Args:
         data: Data to measure
-        format: Format to use ('zon', 'binary', or 'json')
+        format: Format to use ('zonf', 'binary', or 'json')
         
     Returns:
         Size in bytes
         
     Example:
         >>> data = {"name": "Alice", "age": 30}
-        >>> size(data, 'zon')
+        >>> size(data, 'zonf')
         45
         >>> size(data, 'json')
         28
     """
-    if format == 'zon':
+    if format == 'zonf':
         return len(encode(data).encode('utf-8'))
     elif format == 'binary':
         return len(encode_binary(data))
@@ -52,7 +52,7 @@ def compare_formats(data: Any) -> Dict[str, Any]:
         >>> result['savings']['zon_vs_json']
         35.5
     """
-    zon_size = size(data, 'zon')
+    zonf_size = size(data, 'zonf')
     binary_size = size(data, 'binary')
     json_size = size(data, 'json')
 
@@ -64,13 +64,13 @@ def calc_savings(smaller: int, larger: int) -> float:
         return (1 - smaller / larger) * 100
 
     return {
-        'zon': zon_size,
+        'zonf': zonf_size,
         'binary': binary_size,
         'json': json_size,
         'savings': {
-            'zon_vs_json': calc_savings(zon_size, json_size),
+            'zonf_vs_json': calc_savings(zonf_size, json_size),
             'binary_vs_json': calc_savings(binary_size, json_size),
-            'binary_vs_zon': calc_savings(binary_size, zon_size)
+            'binary_vs_zonf': calc_savings(binary_size, zonf_size)
         }
     }
 
@@ -194,8 +194,8 @@ def compare(data1: Any, data2: Any) -> Dict[str, Any]:
         'equal': data1 == data2,
         'data1_type': type(data1).__name__,
         'data2_type': type(data2).__name__,
-        'data1_size': size(data1, 'zon'),
-        'data2_size': size(data2, 'zon')
+        'data1_size': size(data1, 'zonf'),
+        'data2_size': size(data2, 'zonf')
     }
 
 
@@ -220,7 +220,7 @@ def is_safe(data: Any, max_depth: int = 10, max_size: int = 1000000) -> Dict[str
         stats = analyze(data)
         depth = stats['depth']
 
-        encoded_size = size(data, 'zon')
+        encoded_size = size(data, 'zonf')
 
         safe = depth <= max_depth and encoded_size <= max_size
 

zon-format/src/zon/versioning/versioning.py

@@ -19,8 +19,8 @@ class ZonDocumentMetadata:
     schema_id: Optional[str] = None
     """Optional schema identifier (e.g., "user-profile-v2")"""
 
-    encoding: str = 'zon'
-    """Encoding format used ("zon" | "zon-binary")"""
+    encoding: str = 'zonf'
+    """Encoding format used ("zonf" | "zonb")"""
 
     timestamp: Optional[int] = None
     """Unix timestamp when document was created"""
@@ -48,7 +48,7 @@ def from_dict(cls, data: Dict[str, Any]) -> 'ZonDocumentMetadata':
         return cls(
             version=data['version'],
             schema_id=data.get('schemaId'),
-            encoding=data.get('encoding', 'zon'),
+            encoding=data.get('encoding', 'zonf'),
             timestamp=data.get('timestamp'),
             custom=data.get('custom', {})
         )
@@ -58,7 +58,7 @@ def embed_version(
     data: Any,
     version: str,
     schema_id: Optional[str] = None,
-    encoding: str = 'zon'
+    encoding: str = 'zonf'
 ) -> Dict[str, Any]:
     """Embeds version metadata into a data object.
     
@@ -68,7 +68,7 @@ def embed_version(
         data: Data object to add metadata to
         version: Semantic version string (e.g., "1.0.0")
         schema_id: Optional schema identifier
-        encoding: Encoding format ('zon' or 'zon-binary')
+        encoding: Encoding format ('zonf' or 'zonb')
         
     Returns:
         Data object with embedded metadata

zon-format/tests/unit/tools/test_helpers.py

@@ -7,11 +7,11 @@
 class TestSize:
     """Test size calculation"""
 
-    def test_size_zon(self):
+    def test_size_zonf(self):
         """Test ZON size calculation"""
         data = {"name": "Alice", "age": 30}
-        zon_size = size(data, 'zon')
-        assert zon_size > 0
+        zonf_size = size(data, 'zonf')
+        assert zonf_size > 0
 
     def test_size_binary(self):
         """Test binary size calculation"""
@@ -43,7 +43,7 @@ def test_compare_formats_structure(self):
         data = {"test": "value"}
         result = compare_formats(data)
 
-        assert 'zon' in result
+        assert 'zonf' in result
         assert 'binary' in result
         assert 'json' in result
         assert 'savings' in result
@@ -53,16 +53,16 @@ def test_compare_formats_savings(self):
         data = [{"id": i, "name": f"User{i}"} for i in range(10)]
         result = compare_formats(data)
 
-        assert 'zon_vs_json' in result['savings']
+        assert 'zonf_vs_json' in result['savings']
         assert 'binary_vs_json' in result['savings']
-        assert 'binary_vs_zon' in result['savings']
+        assert 'binary_vs_zonf' in result['savings']
 
     def test_compare_formats_all_positive_sizes(self):
         """Test all sizes are positive"""
         data = {"users": [{"id": 1}]}
         result = compare_formats(data)
 
-        assert result['zon'] > 0
+        assert result['zonf'] > 0
         assert result['binary'] > 0
         assert result['json'] > 0
 

zon-format/tests/unit/versioning/test_versioning.py

@@ -35,9 +35,9 @@ def test_embed_version_with_schema_id(self):
     def test_embed_version_with_encoding(self):
         """Test embedding with encoding type"""
         data = {"test": "value"}
-        versioned = embed_version(data, "1.0.0", encoding="zon-binary")
+        versioned = embed_version(data, "1.0.0", encoding="zonb")
 
-        assert versioned['__zon_meta']['encoding'] == "zon-binary"
+        assert versioned['__zon_meta']['encoding'] == "zonb"
 
     def test_embed_version_adds_timestamp(self):
         """Test that timestamp is added"""
@@ -86,10 +86,10 @@ def test_extract_version_from_invalid(self):
     def test_extract_version_preserves_encoding(self):
         """Test that encoding is preserved"""
         data = {"test": "value"}
-        versioned = embed_version(data, "1.0.0", encoding="zon-binary")
+        versioned = embed_version(data, "1.0.0", encoding="zonb")
 
         meta = extract_version(versioned)
-        assert meta.encoding == "zon-binary"
+        assert meta.encoding == "zonb"
 
 
 class TestVersionStripping:
@@ -184,29 +184,29 @@ def test_metadata_to_dict(self):
         meta = ZonDocumentMetadata(
             version="1.0.0",
             schema_id="test",
-            encoding="zon",
+            encoding="zonf",
             timestamp=1234567890
         )
 
         d = meta.to_dict()
         assert d['version'] == "1.0.0"
         assert d['schemaId'] == "test"
-        assert d['encoding'] == "zon"
+        assert d['encoding'] == "zonf"
         assert d['timestamp'] == 1234567890
 
     def test_metadata_from_dict(self):
         """Test creating metadata from dict"""
         d = {
             'version': '2.0.0',
             'schemaId': 'user-profile',
-            'encoding': 'zon-binary',
+            'encoding': 'zonb',
             'timestamp': 9876543210
         }
 
         meta = ZonDocumentMetadata.from_dict(d)
         assert meta.version == '2.0.0'
         assert meta.schema_id == 'user-profile'
-        assert meta.encoding == 'zon-binary'
+        assert meta.encoding == 'zonb'
         assert meta.timestamp == 9876543210
 
     def test_metadata_roundtrip(self):