Implement pydantic validators for string format checks

[MarshalX]

lexicon`s string type has the "type" field which directs strict string pattern https://atproto.com/specs/lexicon

here is the list of these formats (https://atproto.com/specs/lexicon#string-formats):

• at-identifier: either a Handle or a DID
• at-uri: AT-URI
• cid: CID in string format, details specified in Data Model
• datetime: timestamp, details specified below
• did: generic DID Identifier
• handle: Handle Identifier
• nsid: Namespaced Identifier
• tid: Timestamp Identifier (TID)
• record-key: Record Key, matching the general syntax ("any")
• uri: generic URI, details specified below
• language: language code, details specified below

We could make our model validation more strict. For someone who wants to use SDK`s models from the server side. To implement PDS, for example.

snarfed implemented this string validations and kindly shared with us: https://github.com/snarfed/lexrpc/blob/41a858c2c28ad212df64f347270c3a8092743f1b/lexrpc/base.py#L439-L522

    def _validate_string_format(self, val, format):
        """Validates an ATProto string value against a format.

        https://atproto.com/specs/lexicon#string-formats

        Args:
          val (str)
          format (str): one of the ATProto string formats

        Raises:
          ValidationError: if the value is invalid for the given format
        """
        def check(condition):
            if not condition:
                raise ValidationError(f'is invalid for format {format}')

        check(val)

        # TODO: switch to match once we require Python 3.10+
        if format == 'at-identifier':
            check(DID_RE.match(val) or DOMAIN_RE.match(val.lower()))

        elif format == 'at-uri':
            check(len(val) < 8 * 1024)
            check(AT_URI_RE.match(val))
            check('/./' not in val
                  and '/../' not in val
                  and not val.endswith('/.')
                  and not val.endswith('/..'))

        elif format == 'cid':
            # ideally I'd use CID.decode here, but it doesn't support CIDv5,
            # it's too strict about padding, etc.
            check(CID_RE.match(val))

        elif format == 'datetime':
            check('T' in val)

            orig_val = val
            # timezone is required
            val = re.sub(r'([+-][0-9]{2}:[0-9]{2}|Z)$', '', orig_val)
            check(val != orig_val)

            # strip fractional seconds
            val = re.sub(r'\.[0-9]+$', '', val)

            try:
                datetime.fromisoformat(val)
            except ValueError:
                check(False)

        elif format == 'did':
            check(DID_RE.match(val))

        elif format == 'nsid':
            check(len(val) <= 317)
            check(NSID_RE.match(val) and '.' in val)

        elif format in 'handle':
            check(len(val) <= 253)
            check(DOMAIN_RE.match(val.lower()))

        elif format == 'tid':
            check(TID_RE.match(val))
            # high bit, big-endian, can't be 1
            check(not ord(val[0]) & 0x40)

        elif format == 'record-key':
            check(val not in ('.', '..') and RKEY_RE.match(val))

        elif format == 'uri':
            check(len(val) < 8 * 1024)
            check(' ' not in val)
            parsed = urlparse(val)
            check(parsed.scheme
                  and parsed.scheme[0].lower() in string.ascii_lowercase
                  and (parsed.netloc or parsed.path or parsed.query
                       or parsed.fragment))

        elif format == 'language':
            check(LANG_RE.match(val))

        else:
            raise ValidationError(f'unknown format {format}')

the code above is licensed under CC0 1.0 Universal

I see this task as:

• implement pydantic validators. 1 per each string format
• tune models generator to apply validators for fields