Fix/typecheck

[acul71]

Code and Test Changes Documentation

This document outlines the changes made to the code and test files between the current version and commit e01dbd3.

Overview of Changes

The main changes across the codebase include:

1. Enhanced type safety and protocol handling
   • Added comprehensive type hints throughout the codebase
   • Improved protocol validation and error handling
   • Enhanced type checking for protocol operations
2. Improved CID (Content Identifier) support
   • Added support for CIDv1 format
   • Enhanced CID conversion handling
   • Improved CID validation and parsing
3. Better sequence protocol implementation
   • Added proper sequence protocol support
   • Enhanced indexing and slicing operations
   • Improved sequence validation
4. More robust error handling
   • Added specific exception types
   • Enhanced error messages
   • Improved error recovery
5. Codec improvements and optimizations
   • Enhanced codec validation
   • Improved codec performance
   • Added new codec features
6. Enhanced string parsing and validation
   • Improved string format validation
   • Enhanced parsing error handling
   • Added support for new string formats
7. Improved protocol registry handling
   • Enhanced protocol registration
   • Improved protocol lookup
   • Added protocol validation
8. Comprehensive test coverage improvements
   • Added new test cases
   • Enhanced existing tests
   • Improved test organization

Detailed Changes

1. Core Module Changes

multiaddr/multiaddr.py

The Multiaddr class has been significantly enhanced with the following changes:

1. Sequence Protocol Implementation

   • Added proper implementation of Python's sequence protocol
   • Enhanced support for indexing and slicing operations
   • Improved handling of negative indices
   • Added support for sequence operations (len, contains, etc.)

2. Type Hints and Annotations

   • Added comprehensive type hints throughout the class
   • Enhanced type safety for protocol operations
   • Improved type checking for method parameters and return values
   • Added support for generic types where appropriate

3. View Handling

   • Improved handling of keys, values, and items views
   • Enhanced view iteration and access
   • Added support for view operations
   • Improved view performance

4. Negative Indexing

   • Added support for negative indices in sequence operations
   • Enhanced index validation
   • Improved error handling for invalid indices
   • Added bounds checking for indices

5. Protocol Alias Handling

   • Improved handling of protocol aliases
   • Enhanced alias validation
   • Added support for alias operations
   • Improved alias lookup performance

6. Error Handling

   • Enhanced error handling for protocol lookups
   • Improved error messages
   • Added specific exception types
   • Enhanced error recovery

7. String Representation

   • Improved string representation handling
   • Enhanced string formatting
   • Added support for custom string formats
   • Improved string validation

Key changes:

def __getitem__(self, idx: Union[int, slice]) -> Union[Any, Sequence[Any]]:
    if isinstance(idx, slice):
        return list(self)[idx]
    if idx < 0:
        idx = len(self)+idx
    for idx2, value in enumerate(self):
        if idx2 == idx:
            return value
    raise IndexError("Protocol value list index out of range")

def __contains__(self, value: object) -> bool:
    return collections.abc.Sequence.__contains__(self, value)

multiaddr/protocols.py

The protocols module has been enhanced with the following changes:

1. Protocol Registry Handling

   • Improved protocol registration process
   • Enhanced registry validation
   • Added support for registry operations
   • Improved registry performance

2. Type Safety

   • Enhanced type safety for protocol objects
   • Improved type checking
   • Added support for type validation
   • Enhanced type hints

3. Protocol Alias Handling

   • Improved handling of protocol aliases
   • Enhanced alias validation
   • Added support for alias operations
   • Improved alias lookup

4. Protocol Locking

   • Added support for protocol locking
   • Enhanced lock validation
   • Improved lock operations
   • Added lock safety checks

5. Error Handling

   • Enhanced error handling for protocol lookups
   • Improved error messages
   • Added specific exception types
   • Enhanced error recovery

6. String Parsing

   • Improved string parsing and validation
   • Enhanced parsing error handling
   • Added support for new string formats
   • Improved parsing performance

7. Protocol Validation

   • Added support for protocol validation
   • Enhanced validation rules
   • Improved validation performance
   • Added validation error handling

Key changes:

def find_by_name(self, name: str) -> Protocol:
    try:
        return self._names_to_protocols[name]
    except KeyError:
        raise exceptions.ProtocolNotFoundError(name)

def find_by_code(self, code: int) -> Protocol:
    try:
        return self._codes_to_protocols[code]
    except KeyError:
        raise exceptions.ProtocolNotFoundError(code)

multiaddr/transforms.py

The transforms module has been enhanced with the following changes:

1. CID Conversion

   • Improved CID conversion handling
   • Enhanced conversion validation
   • Added support for new CID formats
   • Improved conversion performance

2. Error Handling

   • Enhanced error handling
   • Improved error messages
   • Added specific exception types
   • Enhanced error recovery

3. Type Safety

   • Enhanced type safety
   • Improved type checking
   • Added support for type validation
   • Enhanced type hints

4. CIDv1 Support

   • Added support for CIDv1 format
   • Enhanced CIDv1 validation
   • Improved CIDv1 handling
   • Added CIDv1 conversion

5. String Parsing

   • Enhanced string parsing and validation
   • Improved parsing error handling
   • Added support for new string formats
   • Improved parsing performance

6. Protocol Validation

   • Added support for protocol validation
   • Enhanced validation rules
   • Improved validation performance
   • Added validation error handling

7. Path-based Protocols

   • Added support for path-based protocols
   • Enhanced path validation
   • Improved path handling
   • Added path operations

Key changes:

def string_iter(string: str) -> Generator[Tuple[Protocol, CodecBase, Optional[str]], None, None]:
    if not string:
        raise exceptions.StringParseError("Empty string", string)
    if not string.startswith('/'):
        raise exceptions.StringParseError("Must begin with /", string)
    # consume trailing slashes
    string = string.rstrip('/')
    sp = string.split('/')
    # skip the first element, since it starts with /
    sp.pop(0)
    while sp:
        element = sp.pop(0)
        if not element:  # Skip empty elements from multiple slashes
            continue
        try:
            proto = protocol_with_name(element)
            if proto.codec is None:
                codec = CodecBase()
                codec.SIZE = 0
                codec.IS_PATH = False
            else:
                codec = codec_by_name(proto.codec)
        except (ImportError, exceptions.ProtocolNotFoundError) as exc:
            raise exceptions.StringParseError("Unknown Protocol", string, element) from exc

2. Test Changes

tests/test_multiaddr.py

The test suite for the Multiaddr class has been enhanced with the following changes:

1. Sequence Behavior Tests

   • Added new test cases for sequence behavior
   • Enhanced sequence operation testing
   • Improved sequence validation
   • Added sequence edge case testing

2. Protocol Handling Tests

   • Enhanced test coverage for protocol handling
   • Improved protocol operation testing
   • Added protocol validation testing
   • Enhanced protocol edge case testing

3. Error Handling Tests

   • Improved test cases for error handling
   • Enhanced error message testing
   • Added error recovery testing
   • Improved error edge case testing

4. Negative Indexing Tests

   • Added tests for negative indexing
   • Enhanced index validation testing
   • Improved index edge case testing
   • Added index operation testing

5. Protocol Validation Tests

   • Enhanced test cases for protocol validation
   • Improved validation rule testing
   • Added validation edge case testing
   • Enhanced validation operation testing

6. Path-based Protocol Tests

   • Added tests for path-based protocols
   • Enhanced path validation testing
   • Improved path operation testing
   • Added path edge case testing

Key changes:

def test_sequence_behavior():
    ma = Multiaddr("/ip4/127.0.0.1/udp/1234")
    proto1 = protocol_with_name("ip4")
    proto2 = protocol_with_name("udp")
    value1 = "127.0.0.1"
    value2 = "1234"
    item1 = (proto1, value1)
    item2 = (proto2, value2)

    # Test positive indices
    for idx, (proto, value, item) in enumerate(zip([proto1, proto2], [value1, value2], [item1, item2])):
        assert proto in ma
        assert value in ma.values()
        assert item in ma.items()

tests/test_protocols.py

The test suite for the protocols module has been enhanced with the following changes:

1. Protocol Registry Tests

   • Enhanced test cases for protocol registry
   • Improved registry operation testing
   • Added registry validation testing
   • Enhanced registry edge case testing

2. Protocol Alias Tests

   • Improved test coverage for protocol aliases
   • Enhanced alias operation testing
   • Added alias validation testing
   • Improved alias edge case testing

3. Protocol Locking Tests

   • Added tests for protocol locking
   • Enhanced lock operation testing
   • Improved lock validation testing
   • Added lock edge case testing

4. Error Handling Tests

   • Enhanced test cases for error handling
   • Improved error message testing
   • Added error recovery testing
   • Enhanced error edge case testing

5. Protocol Validation Tests

   • Added tests for protocol validation
   • Enhanced validation rule testing
   • Improved validation operation testing
   • Added validation edge case testing

Key changes:

def test_add_protocol_alias():
    registry = protocols.REGISTRY.copy(unlock=True)
    tcp_proto = protocols.protocol_with_name("tcp")
    registry.add_alias_name("tcp", "abcd")
    registry.add_alias_code(tcp_proto, 123456)

    with pytest.raises(exceptions.ProtocolExistsError):
        registry.add_alias_name("tcp", "abcd")
    with pytest.raises(exceptions.ProtocolExistsError):
        registry.add_alias_code(tcp_proto, 123456)

tests/test_transforms.py

The test suite for the transforms module has been enhanced with the following changes:

1. CID Conversion Tests

   • Added support for CIDv0 to CIDv1 conversion
   • Enhanced conversion testing
   • Improved conversion validation
   • Added conversion edge case testing

2. CID Handling Tests

   • Enhanced test cases for CID handling
   • Improved CID operation testing
   • Added CID validation testing
   • Enhanced CID edge case testing

3. CID Conversion Behavior Tests

   • Improved validation of CID conversion behavior
   • Enhanced conversion rule testing
   • Added conversion operation testing
   • Improved conversion edge case testing

4. Path-based Protocol Tests

   • Added tests for path-based protocols
   • Enhanced path validation testing
   • Improved path operation testing
   • Added path edge case testing

Key changes:

@pytest.mark.parametrize("proto, string, expected", [
    (REGISTRY.find('p2p'),  # This one gets autoconverted to CIDv1
     "12D3KooWPA6ax6t3jqTyGq73Zm1RmwppYqxaXzrtarfcTWGp5Wzx",
     b"\x01\x72\x00\x24\x08\x01\x12\x20\xc6\x35\xed\x47\x2d\x58\xed\xd8\xb9\xee\x46\x41"
     b"\xec\x75\x57\xdc\x80\x6b\x48\x86\xe5\x68\x49\x1a\xb0\x0b\xff\x12\x69\xa7\xbe\x65"),
    (REGISTRY.find('ip6'),  # Others do not
     "12D3KooWPA6ax6t3jqTyGq73Zm1RmwppYqxaXzrtarfcTWGp5Wzx",
     b"\x00\x24\x08\x01\x12\x20\xc6\x35\xed\x47\x2d\x58\xed\xd8\xb9\xee\x46\x41\xec\x75"
     b"\x57\xdc\x80\x6b\x48\x86\xe5\x68\x49\x1a\xb0\x0b\xff\x12\x69\xa7\xbe\x65"),
])
def test_cid_autoconvert_to_bytes(proto, string, expected):
    assert codec_by_name("cid").to_bytes(proto, string) == expected

Summary

The changes reflect a focus on:

1. Improving type safety throughout the codebase

   • Enhanced type hints and annotations
   • Improved type checking and validation
   • Added support for generic types
   • Enhanced type safety features

2. Enhancing protocol handling and validation

   • Improved protocol registration and lookup
   • Enhanced protocol validation rules
   • Added support for protocol operations
   • Improved protocol performance

3. Adding support for newer CID formats

   • Added CIDv1 support
   • Enhanced CID conversion
   • Improved CID validation
   • Added CID operations

4. Improving error handling and reporting

   • Enhanced error messages
   • Added specific exception types
   • Improved error recovery
   • Enhanced error validation

5. Making the codebase more robust and maintainable

   • Improved code organization
   • Enhanced code quality
   • Added code documentation
   • Improved code performance

6. Enhancing string parsing and validation

   • Improved string format validation
   • Enhanced parsing error handling
   • Added support for new formats
   • Improved parsing performance

7. Improving protocol registry handling

   • Enhanced registry operations
   • Improved registry validation
   • Added registry features
   • Enhanced registry performance

8. Increasing test coverage and validation

   • Added new test cases
   • Enhanced existing tests
   • Improved test organization
   • Added test documentation

These updates ensure:

• Better compatibility with Python's type system
• More reliable protocol handling
• Enhanced support for modern address formats
• Improved error handling and debugging
• Better maintainability and code quality
• More robust string parsing and validation
• Enhanced protocol registry functionality
• Comprehensive test coverage

The changes maintain backward compatibility while adding new features and improving existing functionality. The test suite has been significantly enhanced to provide better coverage and validation of the library's features.