commit b300d66aae450a622b45bf352769302cd0287eb7 · dwn.poxiao-labs.work/atpasser

+55 -26

src/atpasser/uri/__init__.py

···

       1
       1
        
       import urllib.parse as up

     

       2
       2
        
       from . import handle, did

     

       3
       3
        
       import jsonpath_ng

     

       4
       4
       +
       from .exceptions import InvalidURIError, ValidationError, URIError

     

       4
       5
        
       

     

       5
       6
        
       

     

       6
       7
        
       class URI:

     
···

       33
       34
        
                   uri (str): The AT Protocol URI string to parse.

     

       34
       35
        
       

     

       35
       36
        
               Raises:

     

       36
       36
       -
                   ValueError: If the URI contains invalid characters, exceeds maximum length,

     

       37
       37
       -
                              doesn't start with 'at://', or has other formatting issues.

     

       37
       37
       +
                   InvalidURIError: If the URI contains invalid characters, exceeds maximum length,

     

       38
       38
       +
                                  doesn't start with 'at://', or has other formatting issues.

     

       39
       39
       +
                   ValidationError: If specific validation checks fail for URI components.

     

       38
       40
        
               """

     

       39
       41
        
       

     

       40
       42
        
               if not set(uri).issubset(set([chr(i) for i in range(0x80)])):

     

       41
       41
       -
                   raise ValueError("invalid char in uri")

     

       43
       43
       +
                   raise InvalidURIError(uri, "contains invalid characters", "URI must only contain ASCII characters")

     

       42
       44
        
       

     

       43
       45
        
               if len(uri) > 8000:

     

       44
       44
       -
                   raise ValueError("uri longer than 8000 chars")  # the doc says 8 "kilobytes"

     

       46
       46
       +
                   raise InvalidURIError(uri, "exceeds maximum length", f"URI length {len(uri)} exceeds maximum allowed length of 8000 characters")

     

       45
       47
        
       

     

       46
       48
        
               if not uri.startswith("at://"):

     

       47
       47
       -
                   raise ValueError("not starts with at://")

     

       49
       49
       +
                   raise InvalidURIError(uri, "invalid format", "URI must start with 'at://'")

     

       48
       50
        
       

     

       49
       51
        
               burner = uri[5:].split("#")

     

       50
       52
        
       

     

       51
       53
        
               try:

     

       52
       54
        
                   fragment = up.unquote(burner[1])

     

       53
       53
       -
               except:

     

       55
       55
       +
               except IndexError:

     

       54
       56
        
                   fragment = None

     

       57
       57
       +
               except Exception as e:

     

       58
       58
       +
                   raise InvalidURIError(uri, "fragment parsing failed", f"Failed to parse URI fragment: {str(e)}")

     

       55
       59
        
       

     

       56
       60
        
               try:

     

       57
       61
        
                   query = up.unquote(burner[0].split("?")[1])

     

       58
       58
       -
               except:

     

       62
       62
       +
               except IndexError:

     

       59
       63
        
                   query = None

     

       64
       64
       +
               except Exception as e:

     

       65
       65
       +
                   raise InvalidURIError(uri, "query parameter parsing failed", f"Failed to parse query parameters: {str(e)}")

     

       60
       66
        
       

     

       61
       61
       -
               path = [up.unquote(segment) for segment in burner[0].split("/")[1:]]

     

       67
       67
       +
               try:

     

       68
       68
       +
                   path = [up.unquote(segment) for segment in burner[0].split("/")[1:]]

     

       69
       69
       +
               except Exception as e:

     

       70
       70
       +
                   raise InvalidURIError(uri, "path parsing failed", f"Failed to parse URI path: {str(e)}")

     

       71
       71
       +
                   

     

       62
       72
        
               if len(path) > 0 and path[-1] == "":

     

       63
       63
       -
                   raise ValueError("trailing slash")

     

       73
       73
       +
                   raise InvalidURIError(uri, "invalid path format", "URI cannot end with a slash")

     

       64
       74
        
       

     

       65
       65
       -
               authorityValue = up.unquote(burner[0].split("/")[0])

     

       75
       75
       +
               try:

     

       76
       76
       +
                   authorityValue = up.unquote(burner[0].split("/")[0])

     

       77
       77
       +
               except Exception as e:

     

       78
       78
       +
                   raise InvalidURIError(uri, "authority parsing failed", f"Failed to parse URI authority: {str(e)}")

     

       66
       79
        
       

     

       67
       67
       -
               p = up.urlparse(up.unquote("//" + authorityValue))

     

       68
       68
       -
               if p.username is not None or p.password is not None:

     

       69
       69
       -
                   raise ValueError("userinfo unsupported")

     

       80
       80
       +
               try:

     

       81
       81
       +
                   p = up.urlparse(up.unquote("//" + authorityValue))

     

       82
       82
       +
                   if p.username is not None or p.password is not None:

     

       83
       83
       +
                       raise InvalidURIError(uri, "unsupported format", "URI does not support user information (username:password)")

     

       84
       84
       +
               except Exception as e:

     

       85
       85
       +
                   if not isinstance(e, InvalidURIError):

     

       86
       86
       +
                       raise InvalidURIError(uri, "authority parsing failed", f"Failed to parse authority: {str(e)}")

     

       87
       87
       +
                   else:

     

       88
       88
       +
                       raise

     

       70
       89
        
       

     

       71
       90
        
               # We decided not to detect if it's a handle there

     

       72
       91
        
               #

     
···

       79
       98
        
               #         raise ValueError("authority is neither handle nor tid")

     

       80
       99
        
       

     

       81
       100
        
               if fragment != None:

     

       82
       82
       -
                   self.fragment = jsonpath_ng.parse(fragment)

     

       83
       83
       -
                   self.fragmentAsText = up.quote(fragment)

     

       101
       101
       +
                   try:

     

       102
       102
       +
                       self.fragment = jsonpath_ng.parse(fragment)

     

       103
       103
       +
                       self.fragmentAsText = up.quote(fragment)

     

       104
       104
       +
                   except Exception as e:

     

       105
       105
       +
                       raise InvalidURIError(uri, "JSONPath parsing failed", f"Failed to parse JSONPath fragment '{fragment}': {str(e)}")

     

       84
       106
        
       

     

       85
       107
        
               if query != None:

     

       86
       86
       -
                   self.query = up.parse_qs(query)

     

       87
       87
       -
                   self.queryAsText = up.quote(query)

     

       108
       108
       +
                   try:

     

       109
       109
       +
                       self.query = up.parse_qs(query)

     

       110
       110
       +
                       self.queryAsText = up.quote(query)

     

       111
       111
       +
                   except Exception as e:

     

       112
       112
       +
                       raise InvalidURIError(uri, "query parameter parsing failed", f"Failed to parse query parameters '{query}': {str(e)}")

     

       88
       113
        
               else:

     

       89
       114
        
                   self.query, self.queryAsText = None, None

     

       90
       115
        
       

     
···

       95
       120
        
               self.authorityAsText = authorityValue

     

       96
       121
        
               try:

     

       97
       122
        
                   authority = handle.Handle(authorityValue)

     

       98
       98
       -
               except:

     

       123
       123
       +
               except Exception as e:

     

       99
       124
        
                   try:

     

       100
       125
        
                       authority = did.DID(authorityValue)

     

       101
       101
       -
                   except:

     

       126
       126
       +
                   except Exception as e2:

     

       127
       127
       +
                       # Don't throw exception, just set authority to None

     

       102
       128
        
                       authority = None

     

       103
       129
        
               self.authority = authority

     

       104
       130
        
       

     

       105
       105
       -
               unescapedAV = up.quote(authorityValue).replace("%3A", ":")

     

       106
       106
       -
               self.uri = "at://{}{}{}{}".format(

     

       107
       107
       -
                   unescapedAV,

     

       108
       108
       -
                   "/" + pathAsText if pathAsText != "" else "",

     

       109
       109
       -
                   "?" + query if query != None else "",

     

       110
       110
       -
                   "?" + fragment if fragment != None else "",

     

       111
       111
       -
               )

     

       131
       131
       +
               try:

     

       132
       132
       +
                   unescapedAV = up.quote(authorityValue).replace("%3A", ":")

     

       133
       133
       +
                   self.uri = "at://{}{}{}{}".format(

     

       134
       134
       +
                       unescapedAV,

     

       135
       135
       +
                       "/" + pathAsText if pathAsText != "" else "",

     

       136
       136
       +
                       "?" + query if query != None else "",

     

       137
       137
       +
                       "#" + fragment if fragment != None else "",

     

       138
       138
       +
                   )

     

       139
       139
       +
               except Exception as e:

     

       140
       140
       +
                   raise InvalidURIError(uri, "URI construction failed", f"Failed to construct canonical URI: {str(e)}")

     

       112
       141
        
       

     

       113
       142
        
           def __str__(self) -> str:

     

       114
       143
        
               """Convert the URI object to its string representation.

+28 -11

src/atpasser/uri/did.py

···

       1
       1
        
       import re

     

       2
       2
        
       from pyld import jsonld

     

       3
       3
       +
       from .exceptions import InvalidDIDError, ResolutionError

     

       3
       4
        
       

     

       4
       5
        
       

     

       5
       6
        
       class DID:

     
···

       25
       26
        
                   uri (str): The DID URI string to validate.

     

       26
       27
        
       

     

       27
       28
        
               Raises:

     

       28
       28
       -
                   ValueError: If the URI doesn't match the DID format or exceeds maximum length.

     

       29
       29
       +
                   InvalidDIDError: If the URI doesn't match the DID format or exceeds maximum length.

     

       29
       30
        
               """

     

       30
       31
        
               pattern = re.compile("^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$")

     

       31
       32
        
               patternMatch = pattern.match(uri)

     

       32
       32
       -
               if patternMatch and len(uri) <= 2048:

     

       33
       33
       -
                   self.uri = patternMatch[0]

     

       34
       34
       -
               else:

     

       35
       35
       -
                   raise ValueError

     

       33
       33
       +
               

     

       34
       34
       +
               if not patternMatch:

     

       35
       35
       +
                   raise InvalidDIDError(uri, "invalid format", "DID must follow 'did:method:identifier' format")

     

       36
       36
       +
                   

     

       37
       37
       +
               if len(uri) > 2048:

     

       38
       38
       +
                   raise InvalidDIDError(uri, "exceeds maximum length", f"DID length {len(uri)} exceeds maximum allowed length of 2048 characters")

     

       39
       39
       +
                   

     

       40
       40
       +
               self.uri = patternMatch[0]

     

       36
       41
        
       

     

       37
       42
        
           def __str__(self) -> str:

     

       38
       43
        
               """Convert the DID object to its string representation.

     
···

       67
       72
        
                   list: The expanded JSON-LD document representing the DID document,

     

       68
       73
        
                         compatible with the PyLD library for further processing.

     

       69
       74
        
       

     

       75
       75
       +
               Raises:

     

       76
       76
       +
                   ResolutionError: If the DID document cannot be fetched or parsed.

     

       77
       77
       +
                   InvalidDIDError: If the DID method is not supported.

     

       78
       78
       +
       

     

       70
       79
        
               Note:

     

       71
       80
        
                   - For 'did:plc:' DIDs, queries https://plc.directory/{did}

     

       72
       81
        
                   - For 'did:web:' DIDs, queries https://{domain}/.well-known/did.json

     

       73
       82
        
               """

     

       74
       74
       -
               if self.uri.startswith("did:plc:"):

     

       75
       75
       -
                   return jsonld.expand(f"https://plc.directory/{self.uri}")

     

       76
       76
       -
               elif self.uri.startswith("did:web"):

     

       77
       77
       -
                   return jsonld.expand(

     

       78
       78
       -
                       f"https://{self.uri.replace("did:web:","")}/.well-known/did.json"

     

       79
       79
       -
                   )

     

       83
       83
       +
               try:

     

       84
       84
       +
                   if self.uri.startswith("did:plc:"):

     

       85
       85
       +
                       return jsonld.expand(f"https://plc.directory/{self.uri}")

     

       86
       86
       +
                   elif self.uri.startswith("did:web:"):

     

       87
       87
       +
                       domain = self.uri.replace("did:web:", "")

     

       88
       88
       +
                       if not domain:

     

       89
       89
       +
                           raise InvalidDIDError(self.uri, "invalid format", "did:web DID must contain a domain")

     

       90
       90
       +
                       return jsonld.expand(f"https://{domain}/.well-known/did.json")

     

       91
       91
       +
                   else:

     

       92
       92
       +
                       raise InvalidDIDError(self.uri, "unsupported DID method", f"Unsupported DID method: {self.uri.split(':')[1]}")

     

       93
       93
       +
               except Exception as e:

     

       94
       94
       +
                   if isinstance(e, (InvalidDIDError, ResolutionError)):

     

       95
       95
       +
                       raise

     

       96
       96
       +
                   raise ResolutionError(self.uri, "fetch DID document", f"Failed to fetch or parse DID document: {str(e)}")

+116

src/atpasser/uri/exceptions.py

···

       1
       1
       +
       """

     

       2
       2
       +
       Custom exception classes for error conditions in AT Protocol URI parsing and processing.

     

       3
       3
       +
       """

     

       4
       4
       +
       

     

       5
       5
       +
       from typing import Optional, Any

     

       6
       6
       +
       

     

       7
       7
       +
       

     

       8
       8
       +
       class URIError(Exception):

     

       9
       9
       +
           """Base class for AT Protocol URI related errors."""

     

       10
       10
       +
           pass

     

       11
       11
       +
       

     

       12
       12
       +
       

     

       13
       13
       +
       class InvalidURIError(URIError):

     

       14
       14
       +
           """Raised when URI format is invalid."""

     

       15
       15
       +
           

     

       16
       16
       +
           def __init__(self, uri: str, reason: str, details: Optional[str] = None):

     

       17
       17
       +
               self.uri = uri

     

       18
       18
       +
               self.reason = reason

     

       19
       19
       +
               self.details = details

     

       20
       20
       +
               message = f"Invalid URI '{uri}': {reason}"

     

       21
       21
       +
               if details:

     

       22
       22
       +
                   message += f" ({details})"

     

       23
       23
       +
               super().__init__(message)

     

       24
       24
       +
       

     

       25
       25
       +
       

     

       26
       26
       +
       class InvalidDIDError(URIError):

     

       27
       27
       +
           """Raised when DID format is invalid."""

     

       28
       28
       +
           

     

       29
       29
       +
           def __init__(self, did: str, reason: str, details: Optional[str] = None):

     

       30
       30
       +
               self.did = did

     

       31
       31
       +
               self.reason = reason

     

       32
       32
       +
               self.details = details

     

       33
       33
       +
               message = f"Invalid DID '{did}': {reason}"

     

       34
       34
       +
               if details:

     

       35
       35
       +
                   message += f" ({details})"

     

       36
       36
       +
               super().__init__(message)

     

       37
       37
       +
       

     

       38
       38
       +
       

     

       39
       39
       +
       class InvalidHandleError(URIError):

     

       40
       40
       +
           """Raised when Handle format is invalid."""

     

       41
       41
       +
           

     

       42
       42
       +
           def __init__(self, handle: str, reason: str, details: Optional[str] = None):

     

       43
       43
       +
               self.handle = handle

     

       44
       44
       +
               self.reason = reason

     

       45
       45
       +
               self.details = details

     

       46
       46
       +
               message = f"Invalid Handle '{handle}': {reason}"

     

       47
       47
       +
               if details:

     

       48
       48
       +
                   message += f" ({details})"

     

       49
       49
       +
               super().__init__(message)

     

       50
       50
       +
       

     

       51
       51
       +
       

     

       52
       52
       +
       class InvalidNSIDError(URIError):

     

       53
       53
       +
           """Raised when NSID format is invalid."""

     

       54
       54
       +
           

     

       55
       55
       +
           def __init__(self, nsid: str, reason: str, details: Optional[str] = None):

     

       56
       56
       +
               self.nsid = nsid

     

       57
       57
       +
               self.reason = reason

     

       58
       58
       +
               self.details = details

     

       59
       59
       +
               message = f"Invalid NSID '{nsid}': {reason}"

     

       60
       60
       +
               if details:

     

       61
       61
       +
                   message += f" ({details})"

     

       62
       62
       +
               super().__init__(message)

     

       63
       63
       +
       

     

       64
       64
       +
       

     

       65
       65
       +
       class InvalidRKeyError(URIError):

     

       66
       66
       +
           """Raised when RKey format is invalid."""

     

       67
       67
       +
           

     

       68
       68
       +
           def __init__(self, rkey: str, reason: str, details: Optional[str] = None):

     

       69
       69
       +
               self.rkey = rkey

     

       70
       70
       +
               self.reason = reason

     

       71
       71
       +
               self.details = details

     

       72
       72
       +
               message = f"Invalid RKey '{rkey}': {reason}"

     

       73
       73
       +
               if details:

     

       74
       74
       +
                   message += f" ({details})"

     

       75
       75
       +
               super().__init__(message)

     

       76
       76
       +
       

     

       77
       77
       +
       

     

       78
       78
       +
       class InvalidRestrictedURIError(URIError):

     

       79
       79
       +
           """Raised when Restricted URI format is invalid."""

     

       80
       80
       +
           

     

       81
       81
       +
           def __init__(self, uri: str, reason: str, details: Optional[str] = None):

     

       82
       82
       +
               self.uri = uri

     

       83
       83
       +
               self.reason = reason

     

       84
       84
       +
               self.details = details

     

       85
       85
       +
               message = f"Invalid Restricted URI '{uri}': {reason}"

     

       86
       86
       +
               if details:

     

       87
       87
       +
                   message += f" ({details})"

     

       88
       88
       +
               super().__init__(message)

     

       89
       89
       +
       

     

       90
       90
       +
       

     

       91
       91
       +
       class ResolutionError(URIError):

     

       92
       92
       +
           """Raised when resolution operation fails."""

     

       93
       93
       +
           

     

       94
       94
       +
           def __init__(self, target: str, operation: str, reason: str, details: Optional[str] = None):

     

       95
       95
       +
               self.target = target

     

       96
       96
       +
               self.operation = operation

     

       97
       97
       +
               self.reason = reason

     

       98
       98
       +
               self.details = details

     

       99
       99
       +
               message = f"Resolution failed for '{target}' during {operation}: {reason}"

     

       100
       100
       +
               if details:

     

       101
       101
       +
                   message += f" ({details})"

     

       102
       102
       +
               super().__init__(message)

     

       103
       103
       +
       

     

       104
       104
       +
       

     

       105
       105
       +
       class ValidationError(URIError):

     

       106
       106
       +
           """Raised when validation operation fails."""

     

       107
       107
       +
           

     

       108
       108
       +
           def __init__(self, value: Any, field: str, reason: str, details: Optional[str] = None):

     

       109
       109
       +
               self.value = value

     

       110
       110
       +
               self.field = field

     

       111
       111
       +
               self.reason = reason

     

       112
       112
       +
               self.details = details

     

       113
       113
       +
               message = f"Validation failed: value '{value}' for field '{field}' {reason}"

     

       114
       114
       +
               if details:

     

       115
       115
       +
                   message += f" ({details})"

     

       116
       116
       +
               super().__init__(message)

+57 -28

src/atpasser/uri/handle.py

···

       1
       1
        
       import dns.resolver, requests

     

       2
       2
        
       

     

       3
       3
        
       from .did import DID

     

       4
       4
       +
       from .exceptions import InvalidHandleError, ResolutionError, InvalidDIDError

     

       4
       5
        
       

     

       5
       6
        
       

     

       6
       7
        
       class Handle:

     
···

       26
       27
        
                   handle (str): The handle string to validate.

     

       27
       28
        
       

     

       28
       29
        
               Raises:

     

       29
       29
       -
                   ValueError: If the handle exceeds maximum length, has invalid domain structure,

     

       30
       30
       -
                              contains invalid characters, or violates other naming rules.

     

       30
       30
       +
                   InvalidHandleError: If the handle exceeds maximum length, has invalid domain structure,

     

       31
       31
       +
                                     contains invalid characters, or violates other naming rules.

     

       31
       32
        
               """

     

       32
       33
        
       

     

       33
       34
        
               if len(handle) > 253:

     

       34
       34
       -
                   raise ValueError("handle is more than 253 chars")

     

       35
       35
       +
                   raise InvalidHandleError(handle, "exceeds maximum length", f"Handle length {len(handle)} exceeds maximum allowed length of 253 characters")

     

       35
       36
        
       

     

       36
       37
        
               labels = handle.lower().split(".")

     

       37
       38
        
       

     

       38
       39
        
               if len(labels) < 2:

     

       39
       39
       -
                   raise ValueError("are you tld?")

     

       40
       40
       +
                   raise InvalidHandleError(handle, "invalid format", "Handle must contain at least one dot separator, e.g., 'example.com'")

     

       40
       41
        
       

     

       41
       42
        
               if labels[0] == "" or labels[-1] == "":

     

       42
       42
       -
                   raise ValueError("proceeding or tariling ascii periods")

     

       43
       43
       +
                   raise InvalidHandleError(handle, "invalid format", "Handle cannot start or end with a dot")

     

       43
       44
        
       

     

       44
       44
       -
               for label in labels:

     

       45
       45
       +
               for i, label in enumerate(labels):

     

       45
       46
        
                   if len(label) not in range(1, 64):

     

       46
       46
       -
                       raise ValueError("two periods or segment longer than 63 char")

     

       47
       47
       +
                       raise InvalidHandleError(handle, "segment length error", f"Handle segment {i+1} length {len(label)} is not in the 1-63 character range")

     

       47
       48
        
                   charset = set(label)

     

       48
       49
        
                   validset = set("abcdefghijklmnopqrstuvwxyz0123456789-")

     

       49
       50
        
                   if not charset.issubset(validset):

     

       50
       50
       -
                       raise ValueError("invalid char used in segment")

     

       51
       51
       +
                       invalid_chars = charset - validset

     

       52
       52
       +
                       raise InvalidHandleError(handle, "contains invalid characters", f"Handle segment {i+1} contains invalid characters: {', '.join(invalid_chars)}")

     

       51
       53
        
                   if label.startswith("-") or label.endswith("-"):

     

       52
       52
       -
                       raise ValueError("segments starts or ends with hyphen")

     

       54
       54
       +
                       raise InvalidHandleError(handle, "invalid format", f"Handle segment {i+1} cannot start or end with a hyphen")

     

       53
       55
        
       

     

       54
       56
        
               tld = labels[-1]

     

       55
       57
        
               if tld[0] in "0123456789":

     

       56
       56
       -
                   raise ValueError("tld starts with digit")

     

       58
       58
       +
                   raise InvalidHandleError(handle, "invalid format", "Handle's top-level domain cannot start with a digit")

     

       57
       59
        
       

     

       58
       60
        
               self.handle = handle

     

       59
       61
        
       

     
···

       94
       96
        
                   atpasser.uri.did.DID or None: A DID object if resolution succeeds,

     

       95
       97
        
                                                None if resolution fails.

     

       96
       98
        
       

     

       99
       99
       +
               Raises:

     

       100
       100
       +
                   ResolutionError: If there's an error during the resolution process.

     

       101
       101
       +
       

     

       97
       102
        
               Note:

     

       98
       103
        
                   Resolution follows AT Protocol specifications:

     

       99
       104
        
                   1. First attempts DNS TXT record lookup for 'did={did}' value

     
···

       101
       106
        
                   3. Returns None if both methods fail

     

       102
       107
        
               """

     

       103
       108
        
               try:

     

       104
       104
       -
                   answers = dns.resolver.resolve("_atproto." + self.handle, "TXT")

     

       105
       105
       -
               except:

     

       106
       106
       -
                   answers = []

     

       107
       107
       -
               for answer in answers:

     

       108
       108
       -
                   if str(answer).startswith('"did='):

     

       109
       109
       -
                       try:

     

       110
       110
       -
                           uri = str(answer)[5:-1]

     

       111
       111
       -
                           return DID(uri)

     

       112
       112
       -
                       except:

     

       113
       113
       -
                           pass  # cannot resolve via dns

     

       114
       114
       -
                   response = requests.get(f"https://{self.handle}/.well-known/atproto-did")

     

       115
       115
       -
                   if response.status_code // 100 != 2:

     

       116
       116
       -
                       return None

     

       117
       117
       -
                   if response.headers.get("Content-Type") != "text/plain":

     

       118
       118
       -
                       pass  # Pass for now, because some sites like neocities, breaks this rule

     

       109
       109
       +
                   # First try DNS resolution

     

       110
       110
       +
                   try:

     

       111
       111
       +
                       answers = dns.resolver.resolve("_atproto." + self.handle, "TXT")

     

       112
       112
       +
                   except Exception as e:

     

       113
       113
       +
                       answers = []

     

       114
       114
       +
                       

     

       115
       115
       +
                   for answer in answers:

     

       116
       116
       +
                       answer_str = str(answer)

     

       117
       117
       +
                       if answer_str.startswith('"did='):

     

       118
       118
       +
                           try:

     

       119
       119
       +
                               uri = answer_str[5:-1]  # Remove '"did=' and '"'

     

       120
       120
       +
                               return DID(uri)

     

       121
       121
       +
                           except InvalidDIDError as e:

     

       122
       122
       +
                               # Continue trying other records or methods

     

       123
       123
       +
                               continue

     

       124
       124
       +
                           except Exception as e:

     

       125
       125
       +
                               raise ResolutionError(self.handle, "DNS resolution", f"Error parsing DNS TXT record: {str(e)}")

     

       126
       126
       +
                   

     

       127
       127
       +
                   # If DNS resolution fails, try HTTP method

     

       119
       128
        
                   try:

     

       120
       120
       -
                       return DID(response.text)

     

       121
       121
       -
                   except:

     

       122
       122
       -
                       return None

     

       129
       129
       +
                       response = requests.get(f"https://{self.handle}/.well-known/atproto-did")

     

       130
       130
       +
                       if response.status_code // 100 != 2:

     

       131
       131
       +
                           return None

     

       132
       132
       +
                           

     

       133
       133
       +
                       # Some websites may return incorrect Content-Type, so here we only warn without throwing an exception

     

       134
       134
       +
                       content_type = response.headers.get("Content-Type")

     

       135
       135
       +
                       if content_type != "text/plain" and content_type:

     

       136
       136
       +
                           # Log warning but don't block processing

     

       137
       137
       +
                           pass

     

       138
       138
       +
                           

     

       139
       139
       +
                       try:

     

       140
       140
       +
                           return DID(response.text.strip())

     

       141
       141
       +
                       except InvalidDIDError:

     

       142
       142
       +
                           return None

     

       143
       143
       +
                   except requests.RequestException as e:

     

       144
       144
       +
                       raise ResolutionError(self.handle, "HTTP request", f"Error requesting well-known endpoint: {str(e)}")

     

       145
       145
       +
                   except Exception as e:

     

       146
       146
       +
                       raise ResolutionError(self.handle, "HTTP parsing", f"Error parsing HTTP response: {str(e)}")

     

       147
       147
       +
                       

     

       148
       148
       +
               except Exception as e:

     

       149
       149
       +
                   if isinstance(e, ResolutionError):

     

       150
       150
       +
                       raise

     

       151
       151
       +
                   raise ResolutionError(self.handle, "resolution", f"Unknown error occurred while resolving Handle: {str(e)}")

+44 -21

src/atpasser/uri/nsid.py

···

       1
       1
       +
       from .exceptions import InvalidNSIDError, ValidationError

     

       2
       2
       +
       

     

       3
       3
       +
       

     

       1
       4
        
       class NSID:

     

       2
       5
        
           """A class representing a NSID (Namespace Identifier) in the AT Protocol.

     

       3
       6
        
       

     
···

       25
       28
        
                   nsid (str): The NSID string to parse and validate.

     

       26
       29
        
       

     

       27
       30
        
               Raises:

     

       28
       28
       -
                   ValueError: If the NSID contains invalid characters, exceeds maximum length,

     

       29
       29
       -
                              has improper segment structure, or violates other naming rules.

     

       31
       31
       +
                   InvalidNSIDError: If the NSID contains invalid characters, exceeds maximum length,

     

       32
       32
       +
                                   has improper segment structure, or violates other naming rules.

     

       33
       33
       +
                   ValidationError: If specific validation checks fail for NSID components.

     

       30
       34
        
               """

     

       31
       35
        
       

     

       32
       36
        
               if "#" in nsid:

     

       33
       33
       -
                   nsidWithoutFragment, fragment = nsid.split("#")

     

       37
       37
       +
                   parts = nsid.split("#", 1)

     

       38
       38
       +
                   if len(parts) != 2:

     

       39
       39
       +
                       raise InvalidNSIDError(nsid, "invalid format", "NSID fragment format is incorrect")

     

       40
       40
       +
                   nsidWithoutFragment, fragment = parts

     

       34
       41
        
               else:

     

       35
       42
        
                   nsidWithoutFragment, fragment = nsid, None

     

       36
       43
        
       

     

       44
       44
       +
               # Check for non-ASCII characters

     

       37
       45
        
               if not set([x for x in nsidWithoutFragment]).issubset(

     

       38
       46
        
                   set([chr(i) for i in range(0x80)])

     

       39
       47
        
               ):

     

       40
       40
       -
                   raise ValueError("nsid contains non-ascii chars")

     

       48
       48
       +
                   raise InvalidNSIDError(nsid, "contains invalid characters", "NSID must only contain ASCII characters")

     

       41
       49
        
       

     

       50
       50
       +
               # Check length

     

       42
       51
        
               if len(nsidWithoutFragment) > 317:

     

       43
       43
       -
                   raise ValueError("length longer than 317 chars")

     

       52
       52
       +
                   raise InvalidNSIDError(nsid, "exceeds maximum length", f"NSID length {len(nsidWithoutFragment)} exceeds maximum allowed length of 317 characters")

     

       44
       53
        
       

     

       45
       54
        
               segments = nsidWithoutFragment.split(".")

     

       46
       55
        
       

     

       56
       56
       +
               # Check for leading or trailing dots

     

       47
       57
        
               if nsidWithoutFragment.startswith(".") or nsidWithoutFragment.endswith("."):

     

       48
       48
       -
                   raise ValueError("invalid, but is that undocumented lol")

     

       58
       58
       +
                   raise InvalidNSIDError(nsid, "invalid format", "NSID cannot start or end with a dot")

     

       49
       59
        
       

     

       60
       60
       +
               # Check segment count

     

       50
       61
        
               if len(segments) < 3:

     

       51
       51
       -
                   raise ValueError("less than 3 segments")

     

       62
       62
       +
                   raise InvalidNSIDError(nsid, "invalid format", f"NSID must contain at least 3 segments, currently has {len(segments)}")

     

       52
       63
        
       

     

       53
       64
        
               domainAuthority = [segment.lower() for segment in segments[0:-1]]

     

       54
       65
        
       

     

       66
       66
       +
               # Check domain authority length

     

       55
       67
        
               if len(".".join(domainAuthority)) > 253:

     

       56
       56
       -
                   raise ValueError("domain authority more than 253 chars")

     

       68
       68
       +
                   raise InvalidNSIDError(nsid, "domain authority length exceeds limit", "Domain authority part length exceeds 253 characters")

     

       57
       69
        
       

     

       58
       58
       -
               for segment in domainAuthority:

     

       70
       70
       +
               # Check each domain segment

     

       71
       71
       +
               for i, segment in enumerate(domainAuthority):

     

       59
       72
        
                   if len(segment) > 63 or segment == "":

     

       60
       60
       -
                       raise ValueError("segment not in 1~63 chars")

     

       73
       73
       +
                       raise InvalidNSIDError(nsid, "segment length error", f"Domain authority segment {i+1} length is not in the 1-63 character range")

     

       61
       74
        
                   if not set(segment).issubset(set("abcdefghijklmnopqrstuvwxyz0123456789-")):

     

       62
       62
       -
                       raise ValueError("domain authority contains invalid chars")

     

       75
       75
       +
                       invalid_chars = set(segment) - set("abcdefghijklmnopqrstuvwxyz0123456789-")

     

       76
       76
       +
                       raise InvalidNSIDError(nsid, "contains invalid characters", f"Domain authority segment {i+1} contains invalid characters: {', '.join(invalid_chars)}")

     

       63
       77
        
                   if segment.startswith("-") or segment.endswith("-"):

     

       64
       64
       -
                       raise ValueError("segment starts or ends with hyphen")

     

       78
       78
       +
                       raise InvalidNSIDError(nsid, "invalid format", f"Domain authority segment {i+1} cannot start or end with a hyphen")

     

       79
       79
       +
                       

     

       80
       80
       +
               # Check if top-level domain starts with a digit

     

       65
       81
        
               if segments[0][0] in "0123456789":

     

       66
       66
       -
                   raise ValueError("tld starts with a digit")

     

       82
       82
       +
                   raise InvalidNSIDError(nsid, "invalid format", "NSID's top-level domain cannot start with a digit")

     

       67
       83
        
       

     

       68
       84
        
               self.domainAuthority = domainAuthority

     

       69
       85
        
               self.domainAuthorityAsText = ".".join(domainAuthority)

     

       70
       86
        
       

     

       71
       87
        
               name = segments[-1]

     

       72
       88
        
       

     

       89
       89
       +
               # Check name

     

       73
       90
        
               if name == "" or len(name) > 63:

     

       74
       74
       -
                   raise ValueError("name null or longer than 63 chars")

     

       91
       91
       +
                   raise InvalidNSIDError(nsid, "name length error", "NSID name cannot be empty and length cannot exceed 63 characters")

     

       75
       92
        
       

     

       76
       93
        
               if not set(name).issubset(

     

       77
       94
        
                   set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

     

       78
       95
        
               ):

     

       79
       79
       -
                   raise ValueError("name contains invalid chars")

     

       96
       96
       +
                   invalid_chars = set(name) - set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

     

       97
       97
       +
                   raise InvalidNSIDError(nsid, "contains invalid characters", f"NSID name contains invalid characters: {', '.join(invalid_chars)}")

     

       80
       98
        
       

     

       81
       99
        
               if name[0] in "0123456789":

     

       82
       82
       -
                   raise ValueError("first char of name is a digit")

     

       100
       100
       +
                   raise InvalidNSIDError(nsid, "invalid format", "NSID name cannot start with a digit")

     

       83
       101
        
       

     

       84
       102
        
               self.name = name

     

       85
       103
        
       

     

       104
       104
       +
               # Check fragment

     

       86
       105
        
               if fragment != None:

     

       87
       87
       -
       

     

       88
       106
        
                   if fragment == "" or len(fragment) > 63:

     

       89
       89
       -
                       raise ValueError("fragment null or longer than 63 chars")

     

       107
       107
       +
                       raise InvalidNSIDError(nsid, "fragment length error", "NSID fragment cannot be empty and length cannot exceed 63 characters")

     

       90
       108
        
       

     

       91
       109
        
                   if not set(fragment).issubset(

     

       92
       110
        
                       set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

     

       93
       111
        
                   ):

     

       94
       94
       -
                       raise ValueError("fragment contains invalid chars")

     

       112
       112
       +
                       invalid_chars = set(fragment) - set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")

     

       113
       113
       +
                       raise InvalidNSIDError(nsid, "contains invalid characters", f"NSID fragment contains invalid characters: {', '.join(invalid_chars)}")

     

       95
       114
        
       

     

       96
       115
        
                   if fragment[0] in "0123456789":

     

       97
       97
       -
                       raise ValueError("first char of fragment is a digit")

     

       116
       116
       +
                       raise InvalidNSIDError(nsid, "invalid format", "NSID fragment cannot start with a digit")

     

       98
       117
        
       

     

       99
       118
        
                   self.fragment = fragment

     

       100
       119
        
       

     

       101
       120
        
               else:

     

       102
       121
        
                   self.fragment = None

     

       103
       122
        
       

     

       104
       104
       -
               self.nsid = ".".join(domainAuthority) + f".{name}" + f"#{fragment}"

     

       123
       123
       +
               # Build NSID string

     

       124
       124
       +
               if fragment is not None:

     

       125
       125
       +
                   self.nsid = ".".join(domainAuthority) + f".{name}" + f"#{fragment}"

     

       126
       126
       +
               else:

     

       127
       127
       +
                   self.nsid = ".".join(domainAuthority) + f".{name}"

     

       105
       128
        
       

     

       106
       129
        
           def __str__(self) -> str:

     

       107
       130
        
               """Convert the NSID object to its string representation.

+31 -24

src/atpasser/uri/restricted.py

···

       1
       1
        
       from . import handle, nsid

     

       2
       2
        
       from . import rkey as rKey

     

       3
       3
        
       from . import URI

     

       4
       4
       +
       from .exceptions import InvalidRestrictedURIError, InvalidURIError

     

       4
       5
        
       

     

       5
       6
        
       

     

       6
       7
        
       

     
···

       30
       31
        
                   uri (str): The AT Protocol URI string to parse as a restricted URI.

     

       31
       32
        
       

     

       32
       33
        
               Raises:

     

       33
       33
       -
                   ValueError: If the URI has query parameters or fragments, invalid authority,

     

       34
       34
       -
                              or too many path segments for a restricted URI format.

     

       34
       34
       +
                   InvalidRestrictedURIError: If the URI has query parameters or fragments, invalid authority,

     

       35
       35
       +
                                           or too many path segments for a restricted URI format.

     

       36
       36
       +
                   InvalidURIError: If the underlying URI validation fails.

     

       35
       37
        
               """

     

       36
       38
        
       

     

       37
       37
       -
               super().__init__(uri)

     

       39
       39
       +
               try:

     

       40
       40
       +
                   super().__init__(uri)

     

       41
       41
       +
               except InvalidURIError:

     

       42
       42
       +
                   raise

     

       43
       43
       +
               except Exception as e:

     

       44
       44
       +
                   raise InvalidURIError(uri, "base URI validation failed", f"Failed to parse base URI: {str(e)}")

     

       38
       45
        
       

     

       39
       39
       -
               if self.query != None and self.fragment != None:

     

       46
       46
       +
               if self.query is not None:

     

       47
       47
       +
                   raise InvalidRestrictedURIError(uri, "query parameters not supported", "Restricted URI cannot contain query parameters")

     

       40
       48
        
       

     

       41
       41
       -
                   raise ValueError("has query and/or fragments")

     

       49
       49
       +
               if self.fragment is not None:

     

       50
       50
       +
                   raise InvalidRestrictedURIError(uri, "fragments not supported", "Restricted URI cannot contain fragments")

     

       42
       51
        
       

     

       43
       43
       -
               if self.authority == None:

     

       52
       52
       +
               if self.authority is None:

     

       53
       53
       +
                   raise InvalidRestrictedURIError(uri, "invalid authority", "Restricted URI must contain a valid DID or Handle")

     

       44
       54
        
       

     

       45
       45
       -
                   raise ValueError("invalid DID or handle")

     

       55
       55
       +
               try:

     

       56
       56
       +
                   if len(self.path) == 0:

     

       57
       57
       +
                       self.collection, self.rkey = None, None

     

       46
       58
        
       

     

       47
       47
       -
               if len(self.path) == 0:

     

       59
       59
       +
                   elif len(self.path) == 1:

     

       60
       60
       +
                       self.collection = nsid.NSID(self.path[0])

     

       61
       61
       +
                       self.rkey = None

     

       48
       62
        
       

     

       49
       49
       -
                   self.collection, self.rkey = None, None

     

       50
       50
       -
       

     

       51
       51
       -
               elif len(self.path) == 1:

     

       52
       52
       -
       

     

       53
       53
       -
                   self.collection = nsid.NSID(self.path[0])

     

       54
       54
       -
       

     

       55
       55
       -
                   self.rkey = None

     

       56
       56
       -
       

     

       57
       57
       -
               elif len(self.path) == 2:

     

       58
       58
       -
       

     

       59
       59
       -
                   self.collection = nsid.NSID(self.path[0])

     

       60
       60
       -
       

     

       61
       61
       -
                   self.rkey = rKey.RKey(self.path[1])

     

       62
       62
       -
               else:

     

       63
       63
       -
       

     

       64
       64
       -
                   raise ValueError("ttoo much path segments")

     

       63
       63
       +
                   elif len(self.path) == 2:

     

       64
       64
       +
                       self.collection = nsid.NSID(self.path[0])

     

       65
       65
       +
                       self.rkey = rKey.RKey(self.path[1])

     

       66
       66
       +
                   else:

     

       67
       67
       +
                       raise InvalidRestrictedURIError(uri, "too many path segments", f"Restricted URI can have at most 2 path segments, currently has {len(self.path)}")

     

       68
       68
       +
               except Exception as e:

     

       69
       69
       +
                   if isinstance(e, (InvalidRestrictedURIError, InvalidURIError)):

     

       70
       70
       +
                       raise

     

       71
       71
       +
                   raise InvalidRestrictedURIError(uri, "parsing error", f"Error occurred while parsing Restricted URI: {str(e)}")

     

       65
       72

+19 -18

src/atpasser/uri/rkey.py

···

       1
       1
       +
       from .exceptions import InvalidRKeyError

     

       2
       2
       +
       

     

       3
       3
       +
       

     

       1
       4
        
       class RKey:

     

       2
       5
        
           """A class representing a Record Key (RKey) in the AT Protocol.

     

       3
       6
        
       

     
···

       22
       25
        
                   recordKey (str): The record key string to validate.

     

       23
       26
        
       

     

       24
       27
        
               Raises:

     

       25
       25
       -
                   ValueError: If the record key is empty, exceeds maximum length,

     

       26
       26
       -
                              is a reserved value, or contains invalid characters.

     

       28
       28
       +
                   InvalidRKeyError: If the record key is empty, exceeds maximum length,

     

       29
       29
       +
                                  is a reserved value, or contains invalid characters.

     

       27
       30
        
               """

     

       28
       31
        
       

     

       29
       29
       -
       

     

       30
       30
       -
               if recordKey == "" or len(recordKey) > 512:

     

       31
       31
       -
       

     

       32
       32
       -
                   raise ValueError("null record key or record key longer than 512 chars")

     

       33
       33
       -
       

     

       34
       34
       -
       

     

       35
       35
       -
               if recordKey == ".." or recordKey == ".":

     

       36
       36
       -
       

     

       37
       37
       -
                   raise ValueError("reserved value . and ..")

     

       38
       38
       -
       

     

       39
       39
       -
       

     

       40
       40
       -
               if not set(recordKey).issubset(

     

       41
       41
       -
       

     

       42
       42
       -
                   set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_:~")

     

       43
       43
       -
               ):

     

       32
       32
       +
               if recordKey == "":

     

       33
       33
       +
                   raise InvalidRKeyError(recordKey, "record key is empty", "Record key cannot be empty")

     

       34
       34
       +
                   

     

       35
       35
       +
               if len(recordKey) > 512:

     

       36
       36
       +
                   raise InvalidRKeyError(recordKey, "exceeds maximum length", f"Record key length {len(recordKey)} exceeds maximum allowed length of 512 characters")

     

       44
       37
        
       

     

       45
       45
       -
                   raise ValueError("invalid char")

     

       38
       38
       +
               if recordKey == "..":

     

       39
       39
       +
                   raise InvalidRKeyError(recordKey, "reserved value", "'..' is a reserved value and cannot be used as a record key")

     

       40
       40
       +
                   

     

       41
       41
       +
               if recordKey == ".":

     

       42
       42
       +
                   raise InvalidRKeyError(recordKey, "reserved value", "'.' is a reserved value and cannot be used as a record key")

     

       46
       43
        
       

     

       44
       44
       +
               valid_chars = set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.-_:~")

     

       45
       45
       +
               if not set(recordKey).issubset(valid_chars):

     

       46
       46
       +
                   invalid_chars = set(recordKey) - valid_chars

     

       47
       47
       +
                   raise InvalidRKeyError(recordKey, "contains invalid characters", f"Record key contains invalid characters: {', '.join(invalid_chars)}")

     

       47
       48
        
       

     

       48
       49
        
               self.recordKey = recordKey

     

       49
       50