e6data-python-connector 2.2.5rc5__tar.gz → 2.2.5rc6__tar.gz

{e6data_python_connector-2.2.5rc5/e6data_python_connector.egg-info → e6data_python_connector-2.2.5rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.5rc5
+Version: 2.2.5rc6
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.2.5rc5-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.5rc6-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6}/README.md

@@ -1,6 +1,6 @@
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.2.5rc5-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.5rc6-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6}/e6data_python_connector/e6data_grpc.py

@@ -487,8 +487,6 @@ class Connection(object):
         active_strategy = shared_strategy.get('active_strategy')
         session_invalidated = shared_strategy.get('session_invalidated', False)
 
-        print('self._session_id', self._session_id, pending_strategy, active_strategy, 'invalidated:', session_invalidated)
-        
         # Check if session was invalidated globally
         if self._session_id and session_invalidated:
             _logger.info("*** Session invalidated due to strategy change, forcing fresh connection")
@@ -545,7 +543,6 @@ class Connection(object):
                         # Check for new strategy in authenticate response
                         if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             new_strategy = authenticate_response.new_strategy.lower()
-                            print('1', new_strategy)
                             if new_strategy != active_strategy:
                                 _logger.info(f"Server indicated new strategy: {new_strategy} (different from current: {active_strategy})")
                                 _set_pending_strategy(new_strategy)
@@ -575,7 +572,6 @@ class Connection(object):
                         # Always try blue first, then green if it fails with 456
                         strategies = ['blue', 'green']
                     last_error = None
-                    print('all strategies', strategies)
                     for strategy in strategies:
                         try:
                             _logger.info(f"Trying strategy: {strategy}")
@@ -592,7 +588,6 @@ class Connection(object):
                                 # Check for new strategy in authenticate response
                                 if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                                     new_strategy = authenticate_response.new_strategy.lower()
-                                    print('2', new_strategy)
                                     if new_strategy != strategy:
                                         _logger.info(f"Server indicated new strategy: {new_strategy} (different from current: {strategy})")
                                         _set_pending_strategy(new_strategy)
@@ -632,7 +627,6 @@ class Connection(object):
                             #     user=self.__username,
                             #     password=self.__password
                             # )
-                            # print('_get_active_strategy()', _get_active_strategy())
                             # authenticate_response = self._client.authenticate(
                             #     authenticate_request,
                             #     metadata=_get_grpc_header(cluster=self.cluster_uuid, strategy=_get_active_strategy())
@@ -641,7 +635,6 @@ class Connection(object):
                             # # Check for new strategy in authenticate response
                             # if hasattr(authenticate_response, 'new_strategy') and authenticate_response.new_strategy:
                             #     new_strategy = authenticate_response.new_strategy.lower()
-                            #     print('3', new_strategy)
                             #     if new_strategy != _get_active_strategy():
                             #         _logger.info(f"Server indicated new strategy during auto-resume: {new_strategy}")
                             #         _set_pending_strategy(new_strategy)
@@ -759,7 +752,6 @@ class Connection(object):
         
         # Check for new strategy in clear response
         if hasattr(clear_response, 'new_strategy') and clear_response.new_strategy:
-            print('4', clear_response.new_strategy)
             _set_pending_strategy(clear_response.new_strategy)
 
     def reopen(self):
@@ -791,7 +783,6 @@ class Connection(object):
         
         # Check for new strategy in cancel response
         if hasattr(cancel_response, 'new_strategy') and cancel_response.new_strategy:
-            print('5', cancel_response.new_strategy)
             _set_pending_strategy(cancel_response.new_strategy)
 
     def dry_run(self, query):
@@ -839,7 +830,6 @@ class Connection(object):
         # Check for new strategy in get tables response
         if hasattr(get_table_response, 'new_strategy') and get_table_response.new_strategy:
             _set_pending_strategy(get_table_response.new_strategy)
-            print('6', get_table_response.new_strategy)
         return list(get_table_response.tables)
 
     def get_columns(self, catalog, database, table):
@@ -868,7 +858,6 @@ class Connection(object):
         # Check for new strategy in get columns response
         if hasattr(get_columns_response, 'new_strategy') and get_columns_response.new_strategy:
             _set_pending_strategy(get_columns_response.new_strategy)
-            print('7', get_columns_response.new_strategy)
         return [{'fieldName': row.fieldName, 'fieldType': row.fieldType} for row in get_columns_response.fieldInfo]
 
     def get_schema_names(self, catalog):
@@ -892,7 +881,6 @@ class Connection(object):
         
         # Check for new strategy in get schema names response
         if hasattr(get_schema_response, 'new_strategy') and get_schema_response.new_strategy:
-            print('8', get_schema_response.new_strategy)
             _set_pending_strategy(get_schema_response.new_strategy)
             
         return list(get_schema_response.schemas)
@@ -1189,12 +1177,11 @@ class Cursor(DBAPICursor):
         
         # Check for new strategy in status response
         if hasattr(status_response, 'new_strategy') and status_response.new_strategy:
-            print('9', status_response.new_strategy)
             _set_pending_strategy(status_response.new_strategy)
             
         return status_response
 
-    # @re_auth
+    @re_auth
     def execute(self, operation, parameters=None, **kwargs):
         """
         Prepare and execute a database operation (query or command).
@@ -1286,7 +1273,6 @@ class Cursor(DBAPICursor):
             # Check for new strategy in prepare response
             if hasattr(prepare_statement_response, 'new_strategy') and prepare_statement_response.new_strategy:
                 new_strategy = prepare_statement_response.new_strategy.lower()
-                print('10', new_strategy)
                 if new_strategy != _get_active_strategy():
                     _logger.info(f"Server indicated new strategy during prepare: {new_strategy}")
                     _set_pending_strategy(new_strategy)
@@ -1312,7 +1298,6 @@ class Cursor(DBAPICursor):
             # Check for new strategy in execute response
             if hasattr(execute_response, 'new_strategy') and execute_response.new_strategy:
                 new_strategy = execute_response.new_strategy.lower()
-                print('11', new_strategy)
                 if new_strategy != _get_active_strategy():
                     _logger.info(f"Server indicated new strategy during execute: {new_strategy}")
                     _set_pending_strategy(new_strategy)
@@ -1349,7 +1334,6 @@ class Cursor(DBAPICursor):
         # Check for new strategy in metadata response
         if hasattr(get_result_metadata_response, 'new_strategy') and get_result_metadata_response.new_strategy:
             new_strategy = get_result_metadata_response.new_strategy.lower()
-            print('13', new_strategy)
             if new_strategy != _get_active_strategy():
                 _logger.info(f"Server indicated new strategy during metadata: {new_strategy}")
                 _set_pending_strategy(new_strategy)
@@ -1431,7 +1415,6 @@ class Cursor(DBAPICursor):
         # Check for new strategy in batch response
         if hasattr(get_next_result_batch_response, 'new_strategy') and get_next_result_batch_response.new_strategy:
             new_strategy = get_next_result_batch_response.new_strategy.lower()
-            print('14', new_strategy)
             if new_strategy != _get_active_strategy():
                 _logger.info(f"Server indicated new strategy during batch: {new_strategy}")
                 _set_pending_strategy(new_strategy)
@@ -1531,7 +1514,6 @@ class Cursor(DBAPICursor):
         
         # Check for new strategy in explain analyze response
         if hasattr(explain_analyze_response, 'new_strategy') and explain_analyze_response.new_strategy:
-            print('15', explain_analyze_response.new_strategy)
             _set_pending_strategy(explain_analyze_response.new_strategy)
             
         return dict(

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6/e6data_python_connector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: e6data-python-connector
-Version: 2.2.5rc5
+Version: 2.2.5rc6
 Summary: Client for the e6data distributed SQL Engine.
 Home-page: https://github.com/e6x-labs/e6data-python-connector
 Author: e6data, Inc.
@@ -38,7 +38,7 @@ Dynamic: summary
 
 # e6data Python Connector
 
-![version](https://img.shields.io/badge/version-2.2.5rc5-blue.svg)
+![version](https://img.shields.io/badge/version-2.2.5rc6-blue.svg)
 
 ## Introduction
 

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6}/e6data_python_connector.egg-info/SOURCES.txt

@@ -33,4 +33,18 @@ e6data_python_connector/server/constants.py
 e6data_python_connector/server/e6x_engine_pb2.py
 e6data_python_connector/server/e6x_engine_pb2.pyi
 e6data_python_connector/server/e6x_engine_pb2_grpc.py
-e6data_python_connector/server/ttypes.py
+e6data_python_connector/server/ttypes.py
+test/__init__.py
+test/analyze_38_nines.py
+test/analyze_binary.py
+test/check_decimal_errors.py
+test/test_decimal128_binary_parsing.py
+test/test_decimal128_parsing.py
+test/test_fix.py
+test/test_improved_parsing.py
+test/test_specific_binary.py
+test/test_user_binary_value.py
+test/tests.py
+test/tests_grpc.py
+test/validate_decimal128.py
+test/verify_decimal_fix.py

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6}/e6data_python_connector.egg-info/top_level.txt

@@ -1 +1,2 @@
 e6data_python_connector
+test

{e6data_python_connector-2.2.5rc5 → e6data_python_connector-2.2.5rc6}/setup.py

@@ -12,7 +12,7 @@
 
 import setuptools
 
-VERSION = (2, 2, 5, 'rc5',)
+VERSION = (2, 2, 5, 'rc6',)
 
 
 def get_long_desc():

e6data_python_connector-2.2.5rc6/test/__init__.py

@@ -0,0 +1 @@
+"""Test package for e6data-python-connector."""

e6data_python_connector-2.2.5rc6/test/analyze_38_nines.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""Analyze the binary value that should decode to 38 nines."""
+
+# The binary value
+binary_data = b'\xb4\xc4\xb3W\xa5y;\x85\xf6u\xdd\xc0\x00\x00\x00\x02'
+
+print(f"Binary data: {binary_data}")
+print(f"Length: {len(binary_data)} bytes")
+print(f"Hex: {binary_data.hex()}")
+
+# Expected value
+expected = "99999999999999999999999999999999999999"
+print(f"Expected: {expected} ({len(expected)} digits)")
+
+# Convert to 128-bit integer
+bits = int.from_bytes(binary_data, byteorder='big')
+print(f"\n128-bit integer: {bits}")
+print(f"Hex: 0x{bits:032x}")
+print(f"Binary: {bin(bits)}")
+
+# Extract IEEE 754-2008 Decimal128 fields
+sign = (bits >> 127) & 1
+combination = (bits >> 110) & 0x1FFFF
+coeff_continuation = bits & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFF
+
+print(f"\nIEEE 754-2008 Decimal128 fields:")
+print(f"Sign: {sign} ({'negative' if sign else 'positive'})")
+print(f"Combination: {combination:017b} (decimal: {combination})")
+print(f"Coefficient continuation: {coeff_continuation}")
+
+# Analyze combination field
+print(f"\nCombination field analysis:")
+top_2_bits = (combination >> 15)
+print(f"Top 2 bits: {top_2_bits:02b}")
+
+if top_2_bits != 0b11:
+    exponent_bits = (combination >> 3) & 0x3FFF
+    msd = combination & 0x7
+    print(f"Exponent bits: {exponent_bits} (0x{exponent_bits:04x})")
+    print(f"MSD: {msd}")
+else:
+    # Check if it's special or has MSD 8-9
+    if (combination >> 12) & 0x7 == 0b111:
+        print("This is NaN")
+    elif (combination >> 12) & 0x7 == 0b110:
+        print("This is Infinity")
+    else:
+        exponent_bits = (combination >> 3) & 0x3FFF
+        msd = 8 + (combination & 0x1)
+        print(f"Exponent bits: {exponent_bits} (0x{exponent_bits:04x})")
+        print(f"MSD (8-9): {msd}")
+
+# Calculate actual exponent
+if 'exponent_bits' in locals():
+    exponent = exponent_bits - 6176  # Bias is 6176
+    print(f"Actual exponent: {exponent}")
+
+# The coefficient for 38 nines should be 99999999999999999999999999999999999999
+# This is a 38-digit number
+print(f"\nExpected coefficient analysis:")
+print(f"38 nines = {int(expected)}")
+print(f"38 nines in hex: 0x{int(expected):x}")
+
+# Let's see if the coefficient continuation could encode this
+print(f"\nCoefficient continuation analysis:")
+print(f"Coefficient continuation: {coeff_continuation}")
+print(f"Coefficient continuation hex: 0x{coeff_continuation:x}")
+
+# The coefficient continuation has 110 bits
+# It needs to encode 37 more digits (after MSD)
+# Using DPD encoding, 3 decimal digits fit in 10 bits
+# So 37 digits would need about 124 bits, but we only have 110 bits
+
+# However, the coefficient for Decimal128 can have at most 34 significant digits
+# So 38 nines might be represented as 1E38 or similar
+
+# Let's check what the actual encoding might be
+print(f"\nPossible interpretations:")
+
+# If it's truly 38 nines, it might be encoded with an exponent
+# 9.999...E37 would give us the right magnitude
+scientific_form = f"9.{'9' * 33}E4"
+print(f"Scientific notation: {scientific_form}")
+
+# Or it could be a special encoding
+# Let's check what the combination field tells us about the exponent
+if 'exponent' in locals():
+    print(f"With exponent {exponent}, coefficient would be scaled by 10^{exponent}")
+    
+    # If exponent is 4, then coefficient of 9999...9999 (34 digits) would give us 38 digits total
+    if exponent == 4:
+        print("This suggests coefficient is 34 nines, scaled by 10^4 to give 38 nines")
+
+# Let's also check byte-by-byte
+print(f"\nByte-by-byte analysis:")
+for i, byte in enumerate(binary_data):
+    print(f"Byte {i:2d}: 0x{byte:02x} ({byte:3d}) {bin(byte)[2:].zfill(8)}")

e6data_python_connector-2.2.5rc6/test/analyze_binary.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Analyze the specific binary value."""
+
+# The specific binary value
+binary_data = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%f\x80'
+
+print(f"Binary data: {binary_data}")
+print(f"Length: {len(binary_data)} bytes")
+print(f"Hex: {binary_data.hex()}")
+
+# Convert to 128-bit integer
+bits = int.from_bytes(binary_data, byteorder='big')
+print(f"128-bit integer: {bits}")
+print(f"Hex: 0x{bits:032x}")
+print(f"Binary: {bin(bits)}")
+
+# Extract IEEE 754-2008 Decimal128 fields
+sign = (bits >> 127) & 1
+combination = (bits >> 110) & 0x1FFFF
+coeff_continuation = bits & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFF
+
+print(f"\nIEEE 754-2008 Decimal128 fields:")
+print(f"Sign: {sign}")
+print(f"Combination: {combination:017b} (decimal: {combination})")
+print(f"Coefficient continuation: {coeff_continuation}")
+
+# The hex representation shows:
+# 00000000000000000000000000256680
+# This means most of the number is zeros, with the last 4 bytes being 0x00256680
+
+# Let's focus on the last 4 bytes: 0x00256680
+last_4_bytes = binary_data[-4:]
+print(f"\nLast 4 bytes: {last_4_bytes.hex()}")
+print(f"As integer: {int.from_bytes(last_4_bytes, byteorder='big')}")
+
+# 0x256680 = 2385536 decimal
+# This suggests the number might be related to this value
+
+# Let's check if this follows the pattern of a small decimal number
+# The fact that most bits are zero suggests this is a small positive number
+
+# Check the combination field
+print(f"\nCombination field analysis:")
+print(f"Top 2 bits: {(combination >> 15):02b}")
+if (combination >> 15) != 0b11:
+    exponent_bits = (combination >> 3) & 0x3FFF
+    msd = combination & 0x7
+    exponent = exponent_bits - 6176
+    print(f"Exponent bits: {exponent_bits}")
+    print(f"Actual exponent: {exponent}")
+    print(f"MSD: {msd}")
+    print(f"This is a normal number")
+else:
+    print("This is a special value (infinity/NaN)")
+
+# Let's see what the actual bytes represent
+print(f"\nByte analysis:")
+for i, byte in enumerate(binary_data):
+    print(f"Byte {i:2d}: 0x{byte:02x} ({byte:3d}) {bin(byte)[2:].zfill(8)}")
+
+print(f"\nNon-zero bytes:")
+for i, byte in enumerate(binary_data):
+    if byte != 0:
+        print(f"Byte {i:2d}: 0x{byte:02x} ({byte:3d}) {bin(byte)[2:].zfill(8)}")
+        
+# The non-zero bytes are at positions 13, 14, 15
+# Byte 13: 0x00 (0)
+# Byte 14: 0x25 (37) -> '%' character
+# Byte 15: 0x66 (102) -> 'f' character  
+# Byte 16: 0x80 (128)

e6data_python_connector-2.2.5rc6/test/check_decimal_errors.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""Check what exceptions Decimal raises."""
+from decimal import Decimal
+import decimal
+
+print("Decimal module exceptions:")
+for attr in dir(decimal):
+    if "Error" in attr or "Exception" in attr:
+        print(f"  - {attr}")
+
+print("\nTrying to create invalid Decimal:")
+try:
+    result = Decimal("not-a-number")
+except Exception as e:
+    print(f"Exception type: {type(e)}")
+    print(f"Exception: {e}")
+    print(f"Module: {type(e).__module__}")
+
+print("\nTrying another invalid case:")
+try:
+    result = Decimal("\x00\x01\x02\x03")
+except Exception as e:
+    print(f"Exception type: {type(e)}")
+    print(f"Exception: {e}")
+    print(f"Module: {type(e).__module__}")

e6data_python_connector-2.2.5rc6/test/test_decimal128_binary_parsing.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+Test script to verify IEEE 754-2008 Decimal128 binary parsing.
+"""
+
+import sys
+import os
+from decimal import Decimal
+
+# Add the parent directory to the path to import e6data_python_connector
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from e6data_python_connector.datainputstream import _binary_to_decimal128, _decode_decimal128_binary
+
+
+def test_specific_binary_value():
+    """Test the specific binary value provided by the user."""
+    
+    print("=== Testing Specific Binary Value ===\n")
+    
+    # The specific binary value from the user
+    binary_data = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%f\x80'
+    
+    print(f"Binary data: {binary_data}")
+    print(f"Length: {len(binary_data)} bytes")
+    print(f"Hex representation: {binary_data.hex()}")
+    
+    # Parse it
+    result = _binary_to_decimal128(binary_data)
+    print(f"Parsed result: {result}")
+    print(f"Type: {type(result)}")
+    
+    # Let's also analyze the binary structure
+    print("\n=== Binary Analysis ===")
+    if len(binary_data) == 16:
+        bits = int.from_bytes(binary_data, byteorder='big')
+        print(f"128-bit integer: {bits}")
+        print(f"Binary representation: {bin(bits)}")
+        
+        # Extract fields
+        sign = (bits >> 127) & 1
+        combination = (bits >> 110) & 0x1FFFF
+        coeff_continuation = bits & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFF
+        
+        print(f"Sign bit: {sign}")
+        print(f"Combination field: {combination} (0x{combination:x})")
+        print(f"Coefficient continuation: {coeff_continuation}")
+        
+        # Check if this is a special value
+        if (combination >> 15) == 0b11:
+            print("This appears to be a special value (infinity/NaN)")
+        else:
+            print("This appears to be a normal number")
+            
+            # Extract exponent and MSD
+            exponent_bits = (combination >> 3) & 0x3FFF
+            msd = combination & 0x7
+            exponent = exponent_bits - 6176
+            
+            print(f"Exponent bits: {exponent_bits}")
+            print(f"Actual exponent: {exponent}")
+            print(f"Most significant digit: {msd}")
+    else:
+        print("Invalid length for Decimal128")
+    
+    print("\n=== Test Complete ===")
+    return result
+
+
+def test_known_decimal128_values():
+    """Test some known Decimal128 values."""
+    
+    print("\n=== Testing Known Decimal128 Values ===\n")
+    
+    # Test zero
+    print("1. Testing zero...")
+    # Binary representation of 0 in Decimal128
+    zero_binary = b'\x00' * 16
+    result = _binary_to_decimal128(zero_binary)
+    print(f"Zero: {zero_binary.hex()} -> {result}")
+    
+    # Test positive one
+    print("\n2. Testing positive one...")
+    # This is a simplified test - actual binary would be more complex
+    # For now, let's test the parsing logic
+    
+    # Test various lengths
+    print("\n3. Testing various lengths...")
+    test_cases = [
+        (b'\x00', "1 byte"),
+        (b'\x00' * 8, "8 bytes"),
+        (b'\x00' * 15, "15 bytes"),
+        (b'\x00' * 16, "16 bytes"),
+        (b'\x00' * 17, "17 bytes")
+    ]
+    
+    for binary_data, description in test_cases:
+        result = _binary_to_decimal128(binary_data)
+        print(f"{description}: {result}")
+    
+    print("\n=== Known Values Test Complete ===")
+
+
+def test_string_compatibility():
+    """Test that string representations still work."""
+    
+    print("\n=== Testing String Compatibility ===\n")
+    
+    test_cases = [
+        "123.456",
+        "-789.012",
+        "0",
+        "1.23E+10",
+        "0.000000000000000001"
+    ]
+    
+    for test_str in test_cases:
+        binary_data = test_str.encode('utf-8')
+        result = _binary_to_decimal128(binary_data)
+        expected = Decimal(test_str)
+        print(f"String '{test_str}': {result} (expected: {expected})")
+        assert result == expected, f"String parsing failed for {test_str}"
+    
+    print("\n✓ String compatibility maintained")
+
+
+def debug_binary_parsing():
+    """Debug the binary parsing for the specific value."""
+    
+    print("\n=== Debugging Binary Parsing ===\n")
+    
+    binary_data = b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00%f\x80'
+    
+    print(f"Input: {binary_data.hex()}")
+    print(f"Length: {len(binary_data)}")
+    
+    # Let's manually parse this
+    bits = int.from_bytes(binary_data, byteorder='big')
+    print(f"As 128-bit integer: {bits}")
+    print(f"As hex: 0x{bits:032x}")
+    print(f"As binary: {bin(bits)}")
+    
+    # The hex is: 00000000000000000000000000256680
+    # The last few bytes are: 00256680
+    # This translates to: 0x00256680 = 2385536
+    
+    # Let's see what this means in Decimal128 format
+    sign = (bits >> 127) & 1
+    combination = (bits >> 110) & 0x1FFFF
+    coeff_continuation = bits & 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFF
+    
+    print(f"\nDecoded fields:")
+    print(f"Sign: {sign}")
+    print(f"Combination: {combination:017b} ({combination})")
+    print(f"Coefficient continuation: {coeff_continuation}")
+    
+    # Check the combination field more closely
+    print(f"\nCombination field analysis:")
+    print(f"Top 2 bits: {(combination >> 15):02b}")
+    print(f"Next 14 bits (exponent): {(combination >> 3) & 0x3FFF}")
+    print(f"Bottom 3 bits (MSD): {combination & 0x7}")
+    
+    if (combination >> 15) != 0b11:
+        exponent_bits = (combination >> 3) & 0x3FFF
+        msd = combination & 0x7
+        exponent = exponent_bits - 6176
+        print(f"Exponent: {exponent}")
+        print(f"MSD: {msd}")
+        
+        # This should give us a clue about the actual value
+        print(f"Raw coefficient continuation: {coeff_continuation}")
+        
+        # Try to decode it
+        result = _decode_decimal128_binary(binary_data)
+        print(f"Decoded result: {result}")
+    else:
+        print("Special value detected")
+
+
+def main():
+    """Run all tests."""
+    try:
+        result = test_specific_binary_value()
+        test_known_decimal128_values()
+        test_string_compatibility()
+        debug_binary_parsing()
+        
+        print(f"\n🎉 All tests completed!")
+        print(f"The specific binary value b'\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00%f\\x80' parsed as: {result}")
+        return True
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)