File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/validators.tar
Back
iban.py 0000644 00000002067 15030212475 0006033 0 ustar 00 """IBAN.""" # standard import re # local from .utils import validator def _char_value(char: str): """A=10, B=11, ..., Z=35.""" return char if char.isdigit() else str(10 + ord(char) - ord("A")) def _mod_check(value: str): """Check if the value string passes the mod97-test.""" # move country code and check numbers to end rearranged = value[4:] + value[:4] return int("".join(_char_value(char) for char in rearranged)) % 97 == 1 @validator def iban(value: str, /): """Return whether or not given value is a valid IBAN code. Examples: >>> iban('DE29100500001061045672') # Output: True >>> iban('123456') # Output: ValidationError(func=iban, ...) Args: value: IBAN string to validate. Returns: (Literal[True]): If `value` is a valid IBAN code. (ValidationError): If `value` is an invalid IBAN code. """ return ( (re.match(r"^[a-z]{2}[0-9]{2}[a-z0-9]{11,30}$", value, re.IGNORECASE) and _mod_check(value)) if value else False ) ip_address.py 0000644 00000010536 15030212475 0007237 0 ustar 00 """IP Address.""" # standard from ipaddress import ( AddressValueError, IPv4Address, IPv4Network, IPv6Address, IPv6Network, NetmaskValueError, ) import re from typing import Optional # local from .utils import validator def _check_private_ip(value: str, is_private: Optional[bool]): if is_private is None: return True if ( any( value.startswith(l_bit) for l_bit in { "10.", # private "192.168.", # private "169.254.", # link-local "127.", # localhost "0.0.0.0", # loopback #nosec } ) or re.match(r"^172\.(?:1[6-9]|2\d|3[0-1])\.", value) # private or re.match(r"^(?:22[4-9]|23[0-9]|24[0-9]|25[0-5])\.", value) # broadcast ): return is_private return not is_private @validator def ipv4( value: str, /, *, cidr: bool = True, strict: bool = False, private: Optional[bool] = None, host_bit: bool = True, ): """Returns whether a given value is a valid IPv4 address. From Python version 3.9.5 leading zeros are no longer tolerated and are treated as an error. The initial version of ipv4 validator was inspired from [WTForms IPAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py Examples: >>> ipv4('123.0.0.7') # Output: True >>> ipv4('1.1.1.1/8') # Output: True >>> ipv4('900.80.70.11') # Output: ValidationError(func=ipv4, args={'value': '900.80.70.11'}) Args: value: IP address string to validate. cidr: IP address string may contain CIDR notation. strict: IP address string is strictly in CIDR notation. private: IP address is public if `False`, private/local/loopback/broadcast if `True`. host_bit: If `False` and host bits (along with network bits) _are_ set in the supplied address, this function raises a validation error. ref [IPv4Network][2]. [2]: https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv4Network Returns: (Literal[True]): If `value` is a valid IPv4 address. (ValidationError): If `value` is an invalid IPv4 address. """ if not value: return False try: if cidr: if strict and value.count("/") != 1: raise ValueError("IPv4 address was expected in CIDR notation") return IPv4Network(value, strict=not host_bit) and _check_private_ip(value, private) return IPv4Address(value) and _check_private_ip(value, private) except (ValueError, AddressValueError, NetmaskValueError): return False @validator def ipv6(value: str, /, *, cidr: bool = True, strict: bool = False, host_bit: bool = True): """Returns if a given value is a valid IPv6 address. Including IPv4-mapped IPv6 addresses. The initial version of ipv6 validator was inspired from [WTForms IPAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py Examples: >>> ipv6('::ffff:192.0.2.128') # Output: True >>> ipv6('::1/128') # Output: True >>> ipv6('abc.0.0.1') # Output: ValidationError(func=ipv6, args={'value': 'abc.0.0.1'}) Args: value: IP address string to validate. cidr: IP address string may contain CIDR annotation. strict: IP address string is strictly in CIDR notation. host_bit: If `False` and host bits (along with network bits) _are_ set in the supplied address, this function raises a validation error. ref [IPv6Network][2]. [2]: https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv6Network Returns: (Literal[True]): If `value` is a valid IPv6 address. (ValidationError): If `value` is an invalid IPv6 address. """ if not value: return False try: if cidr: if strict and value.count("/") != 1: raise ValueError("IPv6 address was expected in CIDR notation") return IPv6Network(value, strict=not host_bit) return IPv6Address(value) except (ValueError, AddressValueError, NetmaskValueError): return False finance.py 0000644 00000006343 15030212475 0006526 0 ustar 00 """Finance.""" from .utils import validator def _cusip_checksum(cusip: str): check, val = 0, None for idx in range(9): c = cusip[idx] if c >= "0" and c <= "9": val = ord(c) - ord("0") elif c >= "A" and c <= "Z": val = 10 + ord(c) - ord("A") elif c >= "a" and c <= "z": val = 10 + ord(c) - ord("a") elif c == "*": val = 36 elif c == "@": val = 37 elif c == "#": val = 38 else: return False if idx & 1: val += val check = check + (val // 10) + (val % 10) return (check % 10) == 0 def _isin_checksum(value: str): check, val = 0, None for idx in range(12): c = value[idx] if c >= "0" and c <= "9" and idx > 1: val = ord(c) - ord("0") elif c >= "A" and c <= "Z": val = 10 + ord(c) - ord("A") elif c >= "a" and c <= "z": val = 10 + ord(c) - ord("a") else: return False if idx & 1: val += val return (check % 10) == 0 @validator def cusip(value: str): """Return whether or not given value is a valid CUSIP. Checks if the value is a valid [CUSIP][1]. [1]: https://en.wikipedia.org/wiki/CUSIP Examples: >>> cusip('037833DP2') True >>> cusip('037833DP3') ValidationFailure(func=cusip, ...) Args: value: CUSIP string to validate. Returns: (Literal[True]): If `value` is a valid CUSIP string. (ValidationError): If `value` is an invalid CUSIP string. """ return len(value) == 9 and _cusip_checksum(value) @validator def isin(value: str): """Return whether or not given value is a valid ISIN. Checks if the value is a valid [ISIN][1]. [1]: https://en.wikipedia.org/wiki/International_Securities_Identification_Number Examples: >>> isin('037833DP2') True >>> isin('037833DP3') ValidationFailure(func=isin, ...) Args: value: ISIN string to validate. Returns: (Literal[True]): If `value` is a valid ISIN string. (ValidationError): If `value` is an invalid ISIN string. """ return len(value) == 12 and _isin_checksum(value) @validator def sedol(value: str): """Return whether or not given value is a valid SEDOL. Checks if the value is a valid [SEDOL][1]. [1]: https://en.wikipedia.org/wiki/SEDOL Examples: >>> sedol('2936921') True >>> sedol('29A6922') ValidationFailure(func=sedol, ...) Args: value: SEDOL string to validate. Returns: (Literal[True]): If `value` is a valid SEDOL string. (ValidationError): If `value` is an invalid SEDOL string. """ if len(value) != 7: return False weights = [1, 3, 1, 7, 3, 9, 1] check = 0 for idx in range(7): c = value[idx] if c in "AEIOU": return False val = None if c >= "0" and c <= "9": val = ord(c) - ord("0") elif c >= "A" and c <= "Z": val = 10 + ord(c) - ord("A") else: return False check += val * weights[idx] return (check % 10) == 0 country.py 0000644 00000035107 15030212475 0006626 0 ustar 00 """Country.""" # local from validators.utils import validator # fmt: off _alpha3_to_alpha2 = { # A "ABW": "AW", "AFG": "AF", "AGO": "AO", "AIA": "AI", "ALB": "AL", "AND": "AD", "ANT": "AN", "ARE": "AE", "ARG": "AR", "ARM": "AM", "ASM": "AS", "ATA": "AQ", "ATF": "TF", "ATG": "AG", "AUS": "AU", "AUT": "AT", "AZE": "AZ", # B "BDI": "BI", "BEL": "BE", "BEN": "BJ", "BFA": "BF", "BGD": "BD", "BGR": "BG", "BHR": "BH", "BHS": "BS", "BIH": "BA", "BLR": "BY", "BLZ": "BZ", "BMU": "BM", "BOL": "BO", "BRA": "BR", "BRB": "BB", "BRN": "BN", "BTN": "BT", "BVT": "BV", "BWA": "BW", # C "CAF": "CF", "CAN": "CA", "CCK": "CC", "CHE": "CH", "CHL": "CL", "CHN": "CN", "CMR": "CM", "COD": "CD", "COG": "CG", "COK": "CK", "COL": "CO", "COM": "KM", "CPV": "CV", "CRI": "CR", "CUB": "CU", "CXR": "CX", "CYM": "KY", "CYP": "CY", "CZE": "CZ", # D "DEU": "DE", "DJI": "DJ", "DMA": "DM", "DNK": "DK", "DOM": "DO", "DZA": "DZ", # E "ECU": "EC", "EGY": "EG", "ERI": "ER", "ESH": "EH", "ESP": "ES", "EST": "EE", "ETH": "ET", # F "FIN": "FI", "FJI": "FJ", "FLK": "FK", "FRA": "FR", "FRO": "FO", "FSM": "FM", # G "GAB": "GA", "GBR": "GB", "GEO": "GE", "GGY": "GG", "GHA": "GH", "GIB": "GI", "GIN": "GN", "GLP": "GP", "GMB": "GM", "GNB": "GW", "GNQ": "GQ", "GRC": "GR", "GRD": "GD", "GRL": "GL", "GTM": "GT", "GUF": "GF", "GUM": "GU", "GUY": "GY", # H "HKG": "HK", "HMD": "HM", "HND": "HN", "HRV": "HR", "HTI": "HT", "HUN": "HU", # I "IDN": "ID", "IMN": "IM", "IND": "IN", "IOT": "IO", "IRL": "IE", "IRN": "IR", "IRQ": "IQ", "ISL": "IS", "ISR": "IL", "ITA": "IT", # J "JAM": "JM", "JEY": "JE", "JOR": "JO", "JPN": "JP", # K "KAZ": "KZ", "KEN": "KE", "KGZ": "KG", "KHM": "KH", "KIR": "KI", "KNA": "KN", "KOR": "KR", "KWT": "KW", # L "LAO": "LA", "LBN": "LB", "LBR": "LR", "LBY": "LY", "LCA": "LC", "LIE": "LI", "LKA": "LK", "LSO": "LS", "LTU": "LT", "LUX": "LU", "LVA": "LV", # M "MAC": "MO", "MAR": "MA", "MCO": "MC", "MDA": "MD", "MDG": "MG", "MDV": "MV", "MEX": "MX", "MHL": "MH", "MKD": "MK", "MLI": "ML", "MLT": "MT", "MMR": "MM", "MNE": "ME", "MNG": "MN", "MNP": "MP", "MOZ": "MZ", "MRT": "MR", "MSR": "MS", "MTQ": "MQ", "MUS": "MU", "MWI": "MW", "MYS": "MY", "MYT": "YT", # N "NAM": "NA", "NCL": "NC", "NER": "NE", "NFK": "NF", "NGA": "NG", "NIC": "NI", "NIU": "NU", "NLD": "NL", "NOR": "NO", "NPL": "NP", "NRU": "NR", "NZL": "NZ", # O "OMN": "OM", # P "PAK": "PK", "PAN": "PA", "PCN": "PN", "PER": "PE", "PHL": "PH", "PLW": "PW", "PNG": "PG", "POL": "PL", "PRI": "PR", "PRK": "KP", "PRT": "PT", "PRY": "PY", "PSE": "PS", "PYF": "PF", # Q "QAT": "QA", # R "REU": "RE", "ROU": "RO", "RUS": "RU", "RWA": "RW", # S "SAU": "SA", "SDN": "SD", "SEN": "SN", "SGP": "SG", "SGS": "GS", "SHN": "SH", "SJM": "SJ", "SLB": "SB", "SLE": "SL", "SLV": "SV", "SMR": "SM", "SOM": "SO", "SPM": "PM", "SRB": "RS", "STP": "ST", "SUR": "SR", "SVK": "SK", "SVN": "SI", "SWE": "SE", "SWZ": "SZ", "SYC": "SC", "SYR": "SY", # T "TCA": "TC", "TCD": "TD", "TGO": "TG", "THA": "TH", "TJK": "TJ", "TKL": "TK", "TKM": "TM", "TLS": "TL", "TON": "TO", "TTO": "TT", "TUN": "TN", "TUR": "TR", "TUV": "TV", "TWN": "TW", "TZA": "TZ", # U "UGA": "UG", "UKR": "UA", "UMI": "UM", "URY": "UY", "USA": "US", "UZB": "UZ", # V "VAT": "VA", "VCT": "VC", "VEN": "VE", "VGB": "VG", "VIR": "VI", "VNM": "VN", "VUT": "VU", # W "WLF": "WF", "WSM": "WS", # Y "YEM": "YE", # Z "ZAF": "ZA", "ZMB": "ZM", "ZWE": "ZW", } _calling_codes = { # A "ABW": "+297", "AFG": "+93", "AGO": "+244", "AIA": "+1-264", "ALB": "+355", "AND": "+376", "ANT": "+599", "ARE": "+971", "ARG": "+54", "ARM": "+374", "ASM": "+1-684", "ATA": "+672", "ATG": "+1-268", "AUS": "+61", "AUT": "+43", "AZE": "+994", # B "BDI": "+257", "BEL": "+32", "BEN": "+229", "BFA": "+226", "BGD": "+880", "BGR": "+359", "BHR": "+973", "BHS": "+1-242", "BIH": "+387", "BLR": "+375", "BLZ": "+501", "BMU": "+1-441", "BOL": "+591", "BRA": "+55", "BRB": "+1-246", "BRN": "+673", "BTN": "+975", "BWA": "+267", # C "CAF": "+236", "CAN": "+1", "CCK": "+61", "CHE": "+41", "CHL": "+56", "CHN": "+86", "CMR": "+237", "COD": "+243", "COG": "+242", "COK": "+682", "COL": "+57", "COM": "+269", "CPV": "+238", "CRI": "+506", "CUB": "+53", "CXR": "+61", "CYM": "+1-345", "CYP": "+357", "CZE": "+420", # D "DEU": "+49", "DJI": "+253", "DMA": "+1-767", "DNK": "+45", "DOM": "+1-809", "DZA": "+213", # E "ECU": "+593", "EGY": "+20", "ERI": "+291", "ESH": "+212", "ESP": "+34", "EST": "+372", "ETH": "+251", # F "FIN": "+358", "FJI": "+679", "FLK": "+500", "FRA": "+33", "FRO": "+298", "FSM": "+691", # G "GAB": "+241", "GBR": "+44", "GEO": "+995", "GGY": "+44-1481", "GHA": "+233", "GIB": "+350", "GIN": "+224", "GLP": "+590", "GMB": "+220", "GNB": "+245", "GNQ": "+240", "GRC": "+30", "GRD": "+1-473", "GRL": "+299", "GTM": "+502", "GUF": "+594", "GUM": "+1-671", "GUY": "+592", # H "HKG": "+852", "HMD": "+672", "HND": "+504", "HRV": "+385", "HTI": "+509", "HUN": "+36", # I "IDN": "+62", "IMN": "+44-1624", "IND": "+91", "IOT": "+246", "IRL": "+353", "IRN": "+98", "IRQ": "+964", "ISL": "+354", "ISR": "+972", "ITA": "+39", # J "JAM": "+1-876", "JEY": "+44-1534", "JOR": "+962", "JPN": "+81", # K "KAZ": "+7", "KEN": "+254", "KGZ": "+996", "KHM": "+855", "KIR": "+686", "KNA": "+1-869", "KOR": "+82", "KWT": "+965", # L "LAO": "+856", "LBN": "+961", "LBR": "+231", "LBY": "+218", "LCA": "+1-758", "LIE": "+423", "LKA": "+94", "LSO": "+266", "LTU": "+370", "LUX": "+352", "LVA": "+371", # M "MAC": "+853", "MAR": "+212", "MCO": "+377", "MDA": "+373", "MDG": "+261", "MDV": "+960", "MEX": "+52", "MHL": "+692", "MKD": "+389", "MLI": "+223", "MLT": "+356", "MMR": "+95", "MNE": "+382", "MNG": "+976", "MNP": "+1-670", "MOZ": "+258", "MRT": "+222", "MSR": "+1-664", "MTQ": "+596", "MUS": "+230", "MWI": "+265", "MYS": "+60", "MYT": "+262", # N "NAM": "+264", "NCL": "+687", "NER": "+227", "NFK": "+672", "NGA": "+234", "NIC": "+505", "NIU": "+683", "NLD": "+31", "NOR": "+47", "NPL": "+977", "NRU": "+674", "NZL": "+64", # O "OMN": "+968", # P "PAK": "+92", "PAN": "+507", "PCN": "+64", "PER": "+51", "PHL": "+63", "PLW": "+680", "PNG": "+675", "POL": "+48", "PRI": "+1-787", "PRK": "+850", "PRT": "+351", "PRY": "+595", "PSE": "+970", "PYF": "+689", # Q "QAT": "+974", # R "REU": "+262", "ROU": "+40", "RUS": "+7", "RWA": "+250", # S "SAU": "+966", "SDN": "+249", "SEN": "+221", "SGP": "+65", "SHN": "+290", "SJM": "+47", "SLB": "+677", "SLE": "+232", "SLV": "+503", "SMR": "+378", "SOM": "+252", "SPM": "+508", "SRB": "+381", "STP": "+239", "SUR": "+597", "SVK": "+421", "SVN": "+386", "SWE": "+46", "SWZ": "+268", "SYC": "+248", "SYR": "+963", # T "TCA": "+1-649", "TCD": "+235", "TGO": "+228", "THA": "+66", "TJK": "+992", "TKL": "+690", "TKM": "+993", "TLS": "+670", "TON": "+676", "TTO": "+1-868", "TUN": "+216", "TUR": "+90", "TUV": "+688", "TWN": "+886", "TZA": "+255", # U "UGA": "+256", "UKR": "+380", "UMI": "+1", "URY": "+598", "USA": "+1", "UZB": "+998", # V "VAT": "+379", "VCT": "+1-784", "VEN": "+58", "VGB": "+1-284", "VIR": "+1-340", "VNM": "+84", "VUT": "+678", # W "WLF": "+681", "WSM": "+685", # Y "YEM": "+967", # Z "ZAF": "+27", "ZMB": "+260", "ZWE": "+263" } _numeric = { "004", "008", "010", "012", "016", "020", "024", "028", "031", "032", "036", "040", "044", "048", "050", "051", "052", "056", "060", "064", "068", "070", "072", "074", "076", "084", "086", "090", "092", "096", "100", "104", "108", "112", "116", "120", "124", "132", "136", "140", "144", "148", "152", "156", "158", "162", "166", "170", "174", "175", "178", "180", "184", "188", "191", "192", "196", "203", "204", "208", "212", "214", "218", "222", "226", "231", "232", "233", "234", "238", "239", "242", "246", "248", "250", "254", "258", "260", "262", "266", "268", "270", "275", "276", "288", "292", "296", "300", "304", "308", "312", "316", "320", "324", "328", "332", "334", "340", "344", "348", "352", "356", "360", "364", "368", "372", "376", "380", "384", "388", "392", "398", "400", "404", "408", "410", "414", "417", "418", "422", "426", "428", "430", "434", "438", "440", "442", "446", "450", "454", "458", "462", "466", "470", "474", "478", "480", "484", "492", "496", "498", "499", "500", "504", "508", "512", "516", "520", "524", "528", "531", "533", "534", "535", "540", "548", "554", "558", "562", "566", "570", "574", "578", "580", "581", "583", "584", "585", "586", "591", "598", "600", "604", "608", "612", "616", "620", "624", "626", "630", "634", "638", "642", "643", "646", "652", "654", "659", "660", "662", "663", "666", "670", "674", "678", "682", "686", "688", "690", "694", "702", "703", "704", "705", "706", "710", "716", "724", "728", "729", "732", "740", "744", "748", "752", "756", "760", "762", "764", "768", "772", "776", "780", "784", "788", "792", "795", "796", "798", "800", "804", "807", "818", "826", "831", "832", "833", "834", "840", "850", "854", "858", "860", "862", "876", "882", "887", "894", } _currency_iso4217 = { # https://en.wikipedia.org/wiki/ISO_4217 "AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BOV", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CKD", "CLF", "CLP", "CNY", "COP", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "IEP", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KID", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS", "VED", "VES", "VND", "VUV", "WST", "XAF", "XCD", "XDR", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWL" } _currency_symbols = { # https://en.wikipedia.org/wiki/Currency_sign_(generic) "؋", "฿", "₵", "₡", "¢", "$", "₫", "֏", "€", "ƒ", "₣", "₲", "₴", "₭", "₾", "£", "₺", "₼", "₦", "₱", "元", "圆", "圓", "﷼", "៛", "₽", "₹", "रू", "රු", "૱", "௹", "꠸", "Rs", "₪", "⃀" "৳", "₸", "₮", "₩", "¥", "円", "₿", "¤" } # fmt: on def _get_code_type(format_type: str): """Returns the type of country code.""" if format_type.isdecimal(): return "numeric" if format_type.isalpha(): if len(format_type) == 2: return "alpha2" if len(format_type) == 3: return "alpha3" return "invalid" @validator def calling_code(value: str, /): """Validates given calling code. This performs country's calling code validation. Examples: >>> calling_code('+91') # Output: True >>> calling_code('-31') # Output: ValidationError(func=calling_code, args={'value': '-31'}) Args: value: Country's calling code string to validate. Returns: (Literal[True]): If `value` is a valid calling code. (ValidationError): If `value` is an invalid calling code. """ if not value: return False return value in set(_calling_codes.values()) @validator def country_code(value: str, /, *, iso_format: str = "auto", ignore_case: bool = False): """Validates given country code. This performs a case-sensitive [ISO 3166][1] country code validation. [1]: https://www.iso.org/iso-3166-country-codes.html Examples: >>> country_code('GB', iso_format='alpha3') # Output: False >>> country_code('USA') # Output: True >>> country_code('840', iso_format='numeric') # Output: True >>> country_code('iN', iso_format='alpha2') # Output: False >>> country_code('ZWE', iso_format='alpha3') # Output: True Args: value: Country code string to validate. iso_format: ISO format to be used. Available options are: `auto`, `alpha2`, `alpha3` and `numeric`. ignore_case: Enable/Disable case-sensitive matching. Returns: (Literal[True]): If `value` is a valid country code. (ValidationError): If `value` is an invalid country code. """ if not value: return False if not (1 < len(value) < 4): return False if iso_format == "auto" and (iso_format := _get_code_type(value)) == "invalid": return False if iso_format == "alpha2": return ( value.upper() in set(_alpha3_to_alpha2.values()) if ignore_case else value in set(_alpha3_to_alpha2.values()) ) if iso_format == "alpha3": return value.upper() in _alpha3_to_alpha2 if ignore_case else value in _alpha3_to_alpha2 return value in _numeric if iso_format == "numeric" else False @validator def currency(value: str, /, *, skip_symbols: bool = True, ignore_case: bool = False): """Validates given currency code. This performs [ISO 4217][1] currency code/symbol validation. [1]: https://www.iso.org/iso-4217-currency-codes.html Examples: >>> currency('USD') # Output: True >>> currency('ZWX') # Output: ValidationError(func=currency, args={'value': 'ZWX'}) Args: value: Currency code/symbol string to validate. skip_symbols: Skip currency symbol validation. ignore_case: Enable/Disable case-sensitive matching. Returns: (Literal[True]): If `value` is a valid currency code. (ValidationError): If `value` is an invalid currency code. """ if not value: return False if not skip_symbols and value in _currency_symbols: return True if len(value) != 3: return False return value.upper() in _currency_iso4217 if ignore_case else value in _currency_iso4217 mac_address.py 0000644 00000001541 15030212475 0007363 0 ustar 00 """MAC Address.""" # standard import re # local from .utils import validator @validator def mac_address(value: str, /): """Return whether or not given value is a valid MAC address. This validator is based on [WTForms MacAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L482 Examples: >>> mac_address('01:23:45:67:ab:CD') # Output: True >>> mac_address('00:00:00:00:00') # Output: ValidationError(func=mac_address, args={'value': '00:00:00:00:00'}) Args: value: MAC address string to validate. Returns: (Literal[True]): If `value` is a valid MAC address. (ValidationError): If `value` is an invalid MAC address. """ return re.match(r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$", value) if value else False hashes.py 0000644 00000007633 15030212475 0006401 0 ustar 00 """Hashes.""" # standard import re # local from .utils import validator @validator def md5(value: str, /): """Return whether or not given value is a valid MD5 hash. Examples: >>> md5('d41d8cd98f00b204e9800998ecf8427e') # Output: True >>> md5('900zz11') # Output: ValidationError(func=md5, args={'value': '900zz11'}) Args: value: MD5 string to validate. Returns: (Literal[True]): If `value` is a valid MD5 hash. (ValidationError): If `value` is an invalid MD5 hash. """ return re.match(r"^[0-9a-f]{32}$", value, re.IGNORECASE) if value else False @validator def sha1(value: str, /): """Return whether or not given value is a valid SHA1 hash. Examples: >>> sha1('da39a3ee5e6b4b0d3255bfef95601890afd80709') # Output: True >>> sha1('900zz11') # Output: ValidationError(func=sha1, args={'value': '900zz11'}) Args: value: SHA1 string to validate. Returns: (Literal[True]): If `value` is a valid SHA1 hash. (ValidationError): If `value` is an invalid SHA1 hash. """ return re.match(r"^[0-9a-f]{40}$", value, re.IGNORECASE) if value else False @validator def sha224(value: str, /): """Return whether or not given value is a valid SHA224 hash. Examples: >>> sha224('d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f') # Output: True >>> sha224('900zz11') # Output: ValidationError(func=sha224, args={'value': '900zz11'}) Args: value: SHA224 string to validate. Returns: (Literal[True]): If `value` is a valid SHA224 hash. (ValidationError): If `value` is an invalid SHA224 hash. """ return re.match(r"^[0-9a-f]{56}$", value, re.IGNORECASE) if value else False @validator def sha256(value: str, /): """Return whether or not given value is a valid SHA256 hash. Examples: >>> sha256( ... 'e3b0c44298fc1c149afbf4c8996fb924' ... '27ae41e4649b934ca495991b7852b855' ... ) # Output: True >>> sha256('900zz11') # Output: ValidationError(func=sha256, args={'value': '900zz11'}) Args: value: SHA256 string to validate. Returns: (Literal[True]): If `value` is a valid SHA256 hash. (ValidationError): If `value` is an invalid SHA256 hash. """ return re.match(r"^[0-9a-f]{64}$", value, re.IGNORECASE) if value else False @validator def sha384(value: str, /): """Return whether or not given value is a valid SHA384 hash. Examples: >>> sha384( ... 'cb00753f45a35e8bb5a03d699ac65007272c32ab0eded163' ... '1a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7' ... ) # Output: True >>> sha384('900zz11') # Output: ValidationError(func=sha384, args={'value': '900zz11'}) Args: value: SHA384 string to validate. Returns: (Literal[True]): If `value` is a valid SHA384 hash. (ValidationError): If `value` is an invalid SHA384 hash. """ return re.match(r"^[0-9a-f]{96}$", value, re.IGNORECASE) if value else False @validator def sha512(value: str, /): """Return whether or not given value is a valid SHA512 hash. Examples: >>> sha512( ... 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce' ... '9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af9' ... '27da3e' ... ) # Output: True >>> sha512('900zz11') # Output: ValidationError(func=sha512, args={'value': '900zz11'}) Args: value: SHA512 string to validate. Returns: (Literal[True]): If `value` is a valid SHA512 hash. (ValidationError): If `value` is an invalid SHA512 hash. """ return re.match(r"^[0-9a-f]{128}$", value, re.IGNORECASE) if value else False hostname.py 0000644 00000010057 15030212475 0006736 0 ustar 00 """Hostname.""" # standard from functools import lru_cache import re from typing import Optional from .domain import domain # local from .ip_address import ipv4, ipv6 from .utils import validator @lru_cache def _port_regex(): """Port validation regex.""" return re.compile( r"^\:(6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|" + r"6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{0,3})$", ) @lru_cache def _simple_hostname_regex(): """Simple hostname validation regex.""" # {0,59} because two characters are already matched at # the beginning and at the end, making the range {1, 61} return re.compile(r"^(?!-)[a-z0-9](?:[a-z0-9-]{0,59}[a-z0-9])?(?<!-)$", re.IGNORECASE) def _port_validator(value: str): """Returns host segment if port is valid.""" if value.count("]:") == 1: # with ipv6 host_seg, port_seg = value.rsplit(":", 1) if _port_regex().match(f":{port_seg}"): return host_seg.lstrip("[").rstrip("]") if value.count(":") == 1: # with ipv4 or simple hostname host_seg, port_seg = value.rsplit(":", 1) if _port_regex().match(f":{port_seg}"): return host_seg return None @validator def hostname( value: str, /, *, skip_ipv6_addr: bool = False, skip_ipv4_addr: bool = False, may_have_port: bool = True, maybe_simple: bool = True, consider_tld: bool = False, private: Optional[bool] = None, # only for ip-addresses rfc_1034: bool = False, rfc_2782: bool = False, ): """Return whether or not given value is a valid hostname. Examples: >>> hostname("ubuntu-pc:443") # Output: True >>> hostname("this-pc") # Output: True >>> hostname("xn----gtbspbbmkef.xn--p1ai:65535") # Output: True >>> hostname("_example.com") # Output: True >>> hostname("123.5.77.88:31000") # Output: True >>> hostname("12.12.12.12") # Output: True >>> hostname("[::1]:22") # Output: True >>> hostname("dead:beef:0:0:0:0000:42:1") # Output: True >>> hostname("[0:0:0:0:0:ffff:1.2.3.4]:-65538") # Output: ValidationError(func=hostname, ...) >>> hostname("[0:&:b:c:@:e:f::]:9999") # Output: ValidationError(func=hostname, ...) Args: value: Hostname string to validate. skip_ipv6_addr: When hostname string cannot be an IPv6 address. skip_ipv4_addr: When hostname string cannot be an IPv4 address. may_have_port: Hostname string may contain port number. maybe_simple: Hostname string maybe only hyphens and alpha-numerals. consider_tld: Restrict domain to TLDs allowed by IANA. private: Embedded IP address is public if `False`, private/local if `True`. rfc_1034: Allow trailing dot in domain/host name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain/Host name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid hostname. (ValidationError): If `value` is an invalid hostname. """ if not value: return False if may_have_port and (host_seg := _port_validator(value)): return ( (_simple_hostname_regex().match(host_seg) if maybe_simple else False) or domain(host_seg, consider_tld=consider_tld, rfc_1034=rfc_1034, rfc_2782=rfc_2782) or (False if skip_ipv4_addr else ipv4(host_seg, cidr=False, private=private)) or (False if skip_ipv6_addr else ipv6(host_seg, cidr=False)) ) return ( (_simple_hostname_regex().match(value) if maybe_simple else False) or domain(value, consider_tld=consider_tld, rfc_1034=rfc_1034, rfc_2782=rfc_2782) or (False if skip_ipv4_addr else ipv4(value, cidr=False, private=private)) or (False if skip_ipv6_addr else ipv6(value, cidr=False)) ) __pycache__/ip_address.cpython-310.pyc 0000644 00000010330 15030212475 0013566 0 ustar 00 o �h^ � @ s� d Z ddlmZmZmZmZmZmZ ddlZddl m Z ddl m Z de de e fd d �Ze d d dd d �de dedede e def dd��Ze d d d d�de dededefdd��ZdS )z IP Address.� )�AddressValueError� IPv4Address� IPv4Network� IPv6Address� IPv6Network�NetmaskValueErrorN)�Optional� )� validator�value� is_privatec sD |d u rdS t � fdd�dD ��s t�d� �s t�d� �r |S | S )NTc 3 s � | ]}� � |�V qd S )N)� startswith)�.0�l_bit�r � �H/usr/local/CyberCP/lib/python3.10/site-packages/validators/ip_address.py� <genexpr> s � � �z$_check_private_ip.<locals>.<genexpr>> �10.�127.�0.0.0.0�169.254.�192.168.z ^172\.(?:1[6-9]|2\d|3[0-1])\.z&^(?:22[4-9]|23[0-9]|24[0-9]|25[0-5])\.)�any�re�match)r r r r r �_check_private_ip s �� � �r TF)�cidr�strict�private�host_bitr r r r c C sp | sdS z&|r!|r| � d�dkrtd��t| | d�o t| |�W S t| �o)t| |�W S tttfy7 Y dS w )a Returns whether a given value is a valid IPv4 address. From Python version 3.9.5 leading zeros are no longer tolerated and are treated as an error. The initial version of ipv4 validator was inspired from [WTForms IPAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py Examples: >>> ipv4('123.0.0.7') # Output: True >>> ipv4('1.1.1.1/8') # Output: True >>> ipv4('900.80.70.11') # Output: ValidationError(func=ipv4, args={'value': '900.80.70.11'}) Args: value: IP address string to validate. cidr: IP address string may contain CIDR notation. strict: IP address string is strictly in CIDR notation. private: IP address is public if `False`, private/local/loopback/broadcast if `True`. host_bit: If `False` and host bits (along with network bits) _are_ set in the supplied address, this function raises a validation error. ref [IPv4Network][2]. [2]: https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv4Network Returns: (Literal[True]): If `value` is a valid IPv4 address. (ValidationError): If `value` is an invalid IPv4 address. F�/r z*IPv4 address was expected in CIDR notation�r )�count� ValueErrorr r r r r )r r r r r r r r �ipv4) s ,�r% )r r r c C s\ | sdS z |r |r| � d�dkrtd��t| | d�W S t| �W S tttfy- Y dS w )ax Returns if a given value is a valid IPv6 address. Including IPv4-mapped IPv6 addresses. The initial version of ipv6 validator was inspired from [WTForms IPAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py Examples: >>> ipv6('::ffff:192.0.2.128') # Output: True >>> ipv6('::1/128') # Output: True >>> ipv6('abc.0.0.1') # Output: ValidationError(func=ipv6, args={'value': 'abc.0.0.1'}) Args: value: IP address string to validate. cidr: IP address string may contain CIDR annotation. strict: IP address string is strictly in CIDR notation. host_bit: If `False` and host bits (along with network bits) _are_ set in the supplied address, this function raises a validation error. ref [IPv6Network][2]. [2]: https://docs.python.org/3/library/ipaddress.html#ipaddress.IPv6Network Returns: (Literal[True]): If `value` is a valid IPv6 address. (ValidationError): If `value` is an invalid IPv6 address. Fr! r z*IPv6 address was expected in CIDR notationr" )r# r$ r r r r )r r r r r r r �ipv6a s ! �r& )�__doc__� ipaddressr r r r r r r �typingr �utilsr �str�boolr r% r& r r r r �<module> s0 ����� �7* __pycache__/uri.cpython-310.pyc 0000644 00000003064 15030212475 0012256 0 ustar 00 o �h � @ sZ d Z ddlmZ ddlmZ ddlmZ defdd�Zdefdd �Zedefd d ��Zd S ) zURI.� )�email)�url)� validator�valuec C � | � d�sdS dS )Nzfile:///FT�� startswith�r � r �A/usr/local/CyberCP/lib/python3.10/site-packages/validators/uri.py� _file_url � r c C r )Nzipfs://FTr r r r r � _ipfs_url r r c s� � sdS t � fdd�dD ��rt� �S � �d�r t� �d��S � �d�r(t� �S � �d�r1t� �S � �d�r8d S � �d �r?d S � �d �rFd S � �d �rMd S � �d �rTd S dS )a� Return whether or not given value is a valid URI. Examples: >>> uri('mailto:example@domain.com') # Output: True >>> uri('file:path.txt') # Output: ValidationError(func=uri, ...) Args: value: URI to validate. Returns: (Literal[True]): If `value` is a valid URI. (ValidationError): If `value` is an invalid URI. Fc 3 s � | ]}� � |�V qd S )Nr )�.0�itemr r r � <genexpr>0 s � �zuri.<locals>.<genexpr>> �ftp�git�irc�ssh�ftps�http�rtmp�rtsp�sftp�https�rtmps�telnetzmailto:zfile:zipfs:zmagnet:?Tztel:zdata:zurn:zurc:)�anyr r r �lstripr r r r r r �uri s. � r N) �__doc__r r �utilsr �strr r r r r r r �<module> s __pycache__/email.cpython-310.pyc 0000644 00000004572 15030212475 0012553 0 ustar 00 o �h� � @ s\ d Z ddlZddlmZ ddlmZ edddddd�ded ed ed ed ed ef dd��ZdS )zeMail.� N� )�hostname)� validatorF)� ipv6_address� ipv4_address� simple_host�rfc_1034�rfc_2782�valuer r r r r c C s� | r | � d�dkr dS | �dd�\}}t|�dks t|�dkr!dS |s%|r:|�d�r8|�d�r8|�d��d�}ndS t�d|tj �rQt t || | d|||d ��S dS ) a� Validate an email address. This was inspired from [Django's email validator][1]. Also ref: [RFC 1034][2], [RFC 5321][3] and [RFC 5322][4]. [1]: https://github.com/django/django/blob/main/django/core/validators.py#L174 [2]: https://www.rfc-editor.org/rfc/rfc1034 [3]: https://www.rfc-editor.org/rfc/rfc5321 [4]: https://www.rfc-editor.org/rfc/rfc5322 Examples: >>> email('someone@example.com') # Output: True >>> email('bogus@@') # Output: ValidationError(email=email, args={'value': 'bogus@@'}) Args: value: eMail string to validate. ipv6_address: When the domain part is an IPv6 address. ipv4_address: When the domain part is an IPv4 address. simple_host: When the domain part is a simple hostname. rfc_1034: Allow trailing dot in domain name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid eMail. (ValidationError): If `value` is an invalid eMail. �@r F�@ � �[�]z�(^[\u0100-\u017F\u0180-\u024F]|[-!#$%&'*+/=?^_`{}|~0-9a-z]+(\.[-!#$%&'*+/=?^_`{}|~0-9a-z]+)*$|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\011.])*"$))�skip_ipv6_addr�skip_ipv4_addr� may_have_port� maybe_simpler r ) �count�rsplit�len� startswith�endswith�lstrip�rstrip�re�match� IGNORECASE�boolr )r r r r r r � username_part� domain_part� r! �C/usr/local/CyberCP/lib/python3.10/site-packages/validators/email.py�email s8 /������r# )�__doc__r r �utilsr �strr r# r! r! r! r" �<module> s. ������� __pycache__/uuid.cpython-310.pyc 0000644 00000002315 15030212475 0012423 0 ustar 00 o �h( � @ sN d Z ddlZddlmZ ddlmZ ddlmZ edeeef fdd ��ZdS ) zUUID.� N)�Union)�UUID� )� validator�valuec C sB | sdS t | t�r dS z t| �pt�d| �W S ty Y dS w )af Return whether or not given value is a valid UUID-v4 string. This validator is based on [WTForms UUID validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L539 Examples: >>> uuid('2bc1c94f-0deb-43e9-92a1-4775189ec9f8') # Output: True >>> uuid('2bc1c94f 0deb-43e9-92a1-4775189ec9f8') # Output: ValidationError(func=uuid, ...) Args: value: UUID string or object to validate. Returns: (Literal[True]): If `value` is a valid UUID. (ValidationError): If `value` is an invalid UUID. FTz4^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$)� isinstancer �re�match� ValueError)r � r �B/usr/local/CyberCP/lib/python3.10/site-packages/validators/uuid.py�uuid s � �r ) �__doc__r �typingr r r �utilsr �strr r r r �<module> s __pycache__/length.cpython-310.pyc 0000644 00000003154 15030212475 0012740 0 ustar 00 o �h� � @ s^ d Z ddlmZ ddlmZ ddlmZ eddd�ded eedf d eedf fd d ��ZdS ) zLength.� )�Union� )�between)� validatorN��min_val�max_val�valuer r c C sF |dur |dk r t d��|dur|dk rt d��ttt| �||d��S )a� Return whether or not the length of given string is within a specified range. Examples: >>> length('something', min_val=2) # Output: True >>> length('something', min_val=9, max_val=9) # Output: True >>> length('something', max_val=5) # Output: ValidationError(func=length, ...) Args: value: The string to validate. min_val: The minimum required length of the string. If not provided, minimum length will not be checked. max_val: The maximum length of the string. If not provided, maximum length will not be checked. Returns: (Literal[True]): If `len(value)` is in between the given conditions. (ValidationError): If `len(value)` is not in between the given conditions. Raises: (ValueError): If either `min_val` or `max_val` is negative. Nr z7Length cannot be negative. `min_val` is less than zero.z7Length cannot be negative. `max_val` is less than zero.r )� ValueError�boolr �len)r r r � r �D/usr/local/CyberCP/lib/python3.10/site-packages/validators/length.py�length s r ) �__doc__�typingr r �utilsr �str�intr r r r r �<module> s 4 __pycache__/__init__.cpython-310.pyc 0000644 00000003374 15030212475 0013222 0 ustar 00 o �h� � @ s� d Z ddlmZ ddlmZmZmZmZmZmZm Z m Z ddl m Z m Z mZ ddlmZ ddlmZmZmZmZ ddlmZ ddlmZ dd lmZmZmZmZ dd l m Z m Z m Z dd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& dd l'm'Z' dd l(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 ddl3m3Z3 ddl4m5Z5m6Z6 ddl7m7Z7 ddl8m8Z8 ddl9m9Z9 ddl:m:Z: ddl;m<Z<m=Z= ddl>m>Z> dZ?dZ@dS )zValidate Anything!� )�between)�amex� card_number�diners�discover�jcb� mastercard�unionpay�visa)� calling_code� country_code�currency)�cron)� bsc_address� btc_address� eth_address� trx_address)�domain)�email)�base16�base32�base58�base64)�cusip�isin�sedol)�md5�sha1�sha224�sha256�sha384�sha512)�hostname) �es_cif�es_doi�es_nie�es_nif�fi_business_id�fi_ssn� fr_department�fr_ssn� ind_aadhar�ind_pan)�iban)�ipv4�ipv6)�length)� mac_address)�slug)�url)�ValidationError� validator)�uuid)5r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r6 r4 r5 z0.33.0N)A�__doc__r �cardr r r r r r r r �countryr r r r �crypto_addressesr r r r r r �encodingr r r r �financer r r �hashesr r r r r r! r" �i18nr# r$ r% r& r' r( r) r* r+ r, r- � ip_addressr. r/ r0 r1 r2 r3 �utilsr4 r5 r6 �__all__� __version__� rC rC �F/usr/local/CyberCP/lib/python3.10/site-packages/validators/__init__.py�<module> s. ( 0 L __pycache__/_extremes.cpython-310.pyc 0000644 00000002767 15030212475 0013463 0 ustar 00 o �h � @ sD d Z ddlmZ ddlmZ eG dd� d��ZeG dd� d��ZdS ) z Extremes.� )�total_ordering)�Anyc @ � e Zd ZdZdefdd�ZdS )�AbsMaxaS An object that is greater than any other object (except itself). Inspired by https://pypi.python.org/pypi/Extremes. Examples: >>> from sys import maxint >>> AbsMax > AbsMin # Output: True >>> AbsMax > maxint # Output: True >>> AbsMax > 99999999999999999 # Output: True �otherc C � |t uS )zGreaterThanOrEqual.)r ��selfr � r �G/usr/local/CyberCP/lib/python3.10/site-packages/validators/_extremes.py�__ge__ � z AbsMax.__ge__N)�__name__� __module__� __qualname__�__doc__r r r r r r r � r c @ r )�AbsMina@ An object that is less than any other object (except itself). Inspired by https://pypi.python.org/pypi/Extremes. Examples: >>> from sys import maxint >>> AbsMin < -maxint # Output: True >>> AbsMin < None # Output: True >>> AbsMin < '' # Output: True r c C r )zLessThanOrEqual.)r r r r r �__le__- r z AbsMin.__le__N)r r r r r r r r r r r r r N)r � functoolsr �typingr r r r r r r �<module> s __pycache__/domain.cpython-310.pyc 0000644 00000004570 15030212475 0012731 0 ustar 00 o �h� � @ sX d Z ddlmZ ddlZddlmZ dd� Zedddd �d ed ed ed efdd��Z dS )zDomain.� )�PathN� )� validatorc c sX � t t�j�d��� �} t| �}| D ]}|�� V qW d � dS 1 s%w Y dS )z Load IANA TLDs as a Generator.z_tld.txtN)r �__file__�parent�joinpath�open�next�strip)�tld_f�_�line� r �D/usr/local/CyberCP/lib/python3.10/site-packages/validators/domain.py� _iana_tld s � �"�r F)� consider_tld�rfc_1034�rfc_2782�valuer r r c C s� | sdS |r| � d��dd�d �� t� vrdS z9|r dnd}|r#dnd}t�d | � oPt�d |� d �d |� d � d|� d� d d|� � | �d��d�tj �W S t ye } zt d| � ��|�d}~ww )a& Return whether or not given value is a valid domain. Examples: >>> domain('example.com') # Output: True >>> domain('example.com/') # Output: ValidationError(func=domain, ...) >>> # Supports IDN domains as well:: >>> domain('xn----gtbspbbmkef.xn--p1ai') # Output: True Args: value: Domain string to validate. consider_tld: Restrict domain to TLDs allowed by IANA. rfc_1034: Allows optional trailing dot in the domain name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain name is of type service record. Allows optional underscores in the domain name. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid domain name. (ValidationError): If `value` is an invalid domain name. Raises: (UnicodeError): If `value` cannot be encoded into `idna` or decoded into `utf-8`. F�.r ���r � z\.?$�$z\s|__+z ^(?:[a-z0-9�]z (?:[a-z0-9-z]{0,61}z[a-z0-9z])?\.)z+[a-z0-9][a-z0-9-_]{0,61}z[a-z]�idnazutf-8zUnable to encode/decode N) �rstrip�rsplit�upperr �re�search�match�encode�decode� IGNORECASE� UnicodeError)r r r r �service_record� trailing_dot�errr r r �domain s0 $$ � ��� ���r( ) �__doc__�pathlibr r �utilsr r �str�boolr( r r r r �<module> s ����� __pycache__/card.cpython-310.pyc 0000644 00000013502 15030212475 0012366 0 ustar 00 o �h� � @ s� d Z ddlZddlmZ edefdd��Zedefdd ��Zedefd d ��Zedefd d ��Zedefdd��Z edefdd��Z edefdd��Z edefdd��Z dS )zCard.� N� )� validator�valuec C sl | sdS z't tt| ��}t|ddd� �}tdd� |ddd� D ��}|| d dkW S ty5 Y dS w ) ai Return whether or not given value is a valid generic card number. This validator is based on [Luhn's algorithm][1]. [1]: https://github.com/mmcloughlin/luhn Examples: >>> card_number('4242424242424242') # Output: True >>> card_number('4242424242424241') # Output: ValidationError(func=card_number, args={'value': '4242424242424241'}) Args: value: Generic card number string to validate Returns: (Literal[True]): If `value` is a valid generic card number. (ValidationError): If `value` is an invalid generic card number. F���N���c s s" � | ] }t td | d��V qdS )� � N)�sum�divmod)�.0�d� r �B/usr/local/CyberCP/lib/python3.10/site-packages/validators/card.py� <genexpr>% s � z card_number.<locals>.<genexpr>r r )�list�map�intr � ValueError)r �digits�odd_sum�even_sumr r r � card_number s �r c C �( t �d�}t| �ot| �dko|�| �S )a� Return whether or not given value is a valid Visa card number. Examples: >>> visa('4242424242424242') # Output: True >>> visa('2223003122003222') # Output: ValidationError(func=visa, args={'value': '2223003122003222'}) Args: value: Visa card number string to validate Returns: (Literal[True]): If `value` is a valid Visa card number. (ValidationError): If `value` is an invalid Visa card number. z^4� ��re�compiler �len�match�r �patternr r r �visa+ � r! c C r )a Return whether or not given value is a valid Mastercard card number. Examples: >>> mastercard('5555555555554444') # Output: True >>> mastercard('4242424242424242') # Output: ValidationError(func=mastercard, args={'value': '4242424242424242'}) Args: value: Mastercard card number string to validate Returns: (Literal[True]): If `value` is a valid Mastercard card number. (ValidationError): If `value` is an invalid Mastercard card number. z#^(51|52|53|54|55|22|23|24|25|26|27)r r r r r r � mastercardA r" r# c C r )a Return whether or not given value is a valid American Express card number. Examples: >>> amex('378282246310005') # Output: True >>> amex('4242424242424242') # Output: ValidationError(func=amex, args={'value': '4242424242424242'}) Args: value: American Express card number string to validate Returns: (Literal[True]): If `value` is a valid American Express card number. (ValidationError): If `value` is an invalid American Express card number. z^(34|37)� r r r r r �amexW r" r% c C r )a� Return whether or not given value is a valid UnionPay card number. Examples: >>> unionpay('6200000000000005') # Output: True >>> unionpay('4242424242424242') # Output: ValidationError(func=unionpay, args={'value': '4242424242424242'}) Args: value: UnionPay card number string to validate Returns: (Literal[True]): If `value` is a valid UnionPay card number. (ValidationError): If `value` is an invalid UnionPay card number. z^62r r r r r r �unionpaym r" r& c C s( t �d�}t| �ot| �dv o|�| �S )a Return whether or not given value is a valid Diners Club card number. Examples: >>> diners('3056930009020004') # Output: True >>> diners('4242424242424242') # Output: ValidationError(func=diners, args={'value': '4242424242424242'}) Args: value: Diners Club card number string to validate Returns: (Literal[True]): If `value` is a valid Diners Club card number. (ValidationError): If `value` is an invalid Diners Club card number. z^(30|36|38|39)> � r r r r r r �diners� r" r( c C r )a� Return whether or not given value is a valid JCB card number. Examples: >>> jcb('3566002020360505') # Output: True >>> jcb('4242424242424242') # Output: ValidationError(func=jcb, args={'value': '4242424242424242'}) Args: value: JCB card number string to validate Returns: (Literal[True]): If `value` is a valid JCB card number. (ValidationError): If `value` is an invalid JCB card number. z^35r r r r r r �jcb� r" r) c C r )a� Return whether or not given value is a valid Discover card number. Examples: >>> discover('6011111111111117') # Output: True >>> discover('4242424242424242') # Output: ValidationError(func=discover, args={'value': '4242424242424242'}) Args: value: Discover card number string to validate Returns: (Literal[True]): If `value` is a valid Discover card number. (ValidationError): If `value` is an invalid Discover card number. z ^(60|64|65)r r r r r r �discover� r" r* ) �__doc__r �utilsr �strr r! r# r% r& r( r) r* r r r r �<module> s& __pycache__/cron.cpython-310.pyc 0000644 00000003334 15030212475 0012420 0 ustar 00 o �h� � @ s< d Z ddlmZ dededefdd�Zedefd d ��Zd S ) zCron.� )� validator� component�min_val�max_valc C sh | dkrdS | � � r|t| � ko|kS S d| v rU| �d�}t|�dks5|d � � r5t|d �dk r7dS |d dkr?dS |d � � oT|t|d � koR|kS S d| v r�| �d�}t|�dksp|d � � rp|d � � srdS t|d �t|d �}}|| ko�|kn o�|| ko�|kn o�||kS d | v r�| �d �D ] }t|||�s� dS q�dS dS ) N�*T�/� r F� �-�,)� isdecimal�int�split�len�_validate_cron_component)r r r �parts�start�end�item� r �B/usr/local/CyberCP/lib/python3.10/site-packages/validators/cron.pyr s0 ( , $8 �r �valuec C s� | sdS z | � � �� \}}}}}W n ty" } ztd�|�d}~ww t|dd�s+dS t|dd�s3dS t|dd�s;dS t|dd �sCdS t|dd �sKdS d S ) a� Return whether or not given value is a valid cron string. Examples: >>> cron('*/5 * * * *') # Output: True >>> cron('30-20 * * * *') # Output: ValidationError(func=cron, ...) Args: value: Cron string to validate. Returns: (Literal[True]): If `value` is a valid cron string. (ValidationError): If `value` is an invalid cron string. FzBadly formatted cron stringNr �; � r � � � T)�stripr � ValueErrorr )r �minutes�hours�days�months�weekdays�errr r r �cron) s& �� r% N)�__doc__�utilsr �strr r r% r r r r �<module> s " __pycache__/between.cpython-310.pyc 0000644 00000004703 15030212475 0013111 0 ustar 00 o �h� � @ s� d Z ddlmZ ddlmZmZ ddlmZmZ ddlm Z ede e e ed�Z e ddd �d e d ee edf d ee edf fd d��ZdS )zBetween.� )�datetime)�TypeVar�Union� )�AbsMax�AbsMin)� validator�PossibleValueTypesN)�min_val�max_val�valuer r c C sx | du rdS |du r t � }|du rt� }z ||kr td��W n ty/ } ztd�|�d}~ww || ko9|kS S )a: Validate that a number is between minimum and/or maximum value. This will work with any comparable type, such as floats, decimals and dates not just integers. This validator is originally based on [WTForms-NumberRange-Validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L166-L220 Examples: >>> from datetime import datetime >>> between(5, min_val=2) # Output: True >>> between(13.2, min_val=13, max_val=14) # Output: True >>> between(500, max_val=400) # Output: ValidationError(func=between, args=...) >>> between( ... datetime(2000, 11, 11), ... min_val=datetime(1999, 11, 11) ... ) # Output: True Args: value: Value which is to be compared. min_val: The minimum required value of the number. If not provided, minimum value will not be checked. max_val: The maximum value of the number. If not provided, maximum value will not be checked. Returns: (Literal[True]): If `value` is in between the given conditions. (ValidationError): If `value` is not in between the given conditions. Raises: (ValueError): If `min_val` is greater than `max_val`. (TypeError): If there's a type mismatch during comparison. Note: - `PossibleValueTypes` = `TypeVar("PossibleValueTypes", int, float, str, datetime)` - If neither `min_val` nor `max_val` is provided, result will always be `True`. NFz*`min_val` cannot be greater than `max_val`zComparison type mismatch)r r � ValueError� TypeError)r r r �err� r �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/between.py�between s 3� ��r )�__doc__r �typingr r � _extremesr r �utilsr �int�float�strr r r r r r �<module> s �� � � __pycache__/country.cpython-310.pyc 0000644 00000036702 15030212475 0013167 0 ustar 00 o �hG: � @ s� d Z ddlmZ i dd�dd�dd�d d �d d �d d�dd�dd�dd�dd�dd�dd�dd �d d �d d �d!d"�d#d$�i d%d&�d'd(�d)d*�d+d,�d-d.�d/d0�d1d2�d3d4�d5d6�d7d8�d9d:�d;d<�d=d>�d?d@�dAdB�dCdD�dEdF��i dGdH�dIdJ�dKdL�dMdN�dOdP�dQdR�dSdT�dUdV�dWdX�dYdZ�d[d\�d]d^�d_d`�dadb�dcdd�dedf�dgdh��i didj�dkdl�dmdn�dodp�dqdr�dsdt�dudv�dwdx�dydz�d{d|�d}d~�dd��d�d��d�d��d�d��d�d��d�d���i d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d���i d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�d��d�dd�dēd�dƓd�dȓd�dʓd�d̓d�dΓ�i d�dГd�dғd�dԓd�d֓d�dؓd�dړd�dܓd�dޓd�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d�d��i d�d�d�d�d�d��d�d��d�d��d�d��d�d��d��d ��d�d��d�d��d�d��d�d��d �d ��d �d ��d �d��d�d��d�d��i �d�d��d�d��d�d��d�d��d�d ��d �d ��d �d ��d!�d"��d#�d$��d%�d&��d'�d(��d)�d*��d+�d,��d-�d.��d/�d0��d1�d2��d3�d4��i �d5�d6��d7�d8��d9�d:��d;�d<��d=�d>��d?�d@��dA�dB��dC�dD��dE�dF��dG�dH��dI�dJ��dK�dL��dM�dN��dO�dP��dQ�dR��dS�dT��dU�dV��i �dW�dX��dY�dZ��d[�d\��d]�d^��d_�d`��da�db��dc�dd��de�df��dg�dh��di�dj��dk�dl��dm�dn��do�dp��dq�dr��ds�dt��du�dv��dw�dx��i �dy�dz��d{�d|��d}�d~��d�d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �d��d���d��d���d��d�dÐdē�dŐdƓ�dǐdȓ�dɐdʓ�dːd̓�d͐dΓ�dϐdГ�dѐdғ�dӐdԓ�dՐd֓�dאdؓ�dِdړ�dېdܓ�dݐdޓ��dߐd�d�d�d��Zi d�d�d�d�d�d�d �d�d �d�d �d�d�d�d�d�d�d�d�d�d�d�d�d�d �d�d �d�d!�d�d#�d�d%�d�i d'�d��d)�d��d+�d��d-�d��d/�d��d1�d��d3�d��d5�d��d7�d��d9�d��d;�d��d=�d �d?�d�dA�d�dC�d�dE�d�dI�d��i dK�d�dM�d�dO�d�dQ�d�dS�d �dU�d �dW�d �dY�d �d[�d �d]�d�d_�d�da�d�dc�d�de�d�dg�d�di�d�dk�d��i dm�d�do�d�dq�d�ds�d�du�d�dw�d�dy�d�d{�d �d}�d �d�d �d��d �d��d �d��d!�d��d"�d��d#�d��d$�d��d%��i d��d&�d��d'�d��d(�d��d)�d��d*�d��d+�d��d,�d��d-�d��d.�d��d/�d��d0�d��d1�d��d2�d��d3�d��d4�d��d5�d��d6��i d��d7�d��d8�d��d9�d��d:�d��d;�d��d<�d��d�d��d=�d��d>�dÐd?�dŐd@�dǐdA�dɐdB�dːdC�d͐dD�dϐdE�dѐdF��i dӐdG�dՐdH�dאdI�dِdJ�dېdK�dݐdL�dߐdM�d�dN�d�dO�d�dP�d�dQ�d�dR�d�dS�d�dT�d�dU�d�dV�d�dW��i d��dX�d��dY�d��dZ�d��d[�d��d\�d��d]��d�d^��d�d_��d�d`��d�da��d �db��d �d ��d �dc��d�dd��d�de��d�df��d�dg��i �d�dh��d�di��d�dj��d �dk��d �dl��d!�dm��d#�dn��d%�do��d'�dp��d)�dq��d+�dr��d-�ds��d/�dt��d1�du��d3�dv��d5�dw��d7�dx��i �d9�dy��d;�dz��d=�d��d?�d{��dA�d|��dC�d}��dE�d~��dG�d��dI�d���dK�d���dM�d���dO�d���dQ�d���dS�d���dU�d���dW�d���dY�d���i �d[�d���d]�d���d_�d���da�d���dc�d���de�d���dg�d���di�d���dk�d���dm�d���do�dw��dq�d���ds�dO��du�d���dw�d���dy�d���d{�d���i �d}�d���d��d���d��d��d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���d��d���i �dÐd���dŐd��dǐd���dɐd��dːd���d͐d���dϐd���dѐd���dӐd���dՐd���dאd���dِd���dېd�dݐdÓ�dĐdœ�dƐdǓ�dȐdɓ��dʐd�i�Zh �ḍZh �dͣZh �dΣZ�d�ef�dАdфZ e�d�ef�dӐdԄ�Z e�dՐddל�d�e�d�e�d�e f�dڐdۄ�Z e�dܐddݜ�d�e�d�e �d�e f�dߐd��Z �d�S (� zCountry.� )� validator�ABW�AW�AFG�AF�AGO�AO�AIA�AI�ALB�AL�AND�AD�ANT�AN�ARE�AE�ARG�AR�ARM�AM�ASM�AS�ATA�AQ�ATF�TF�ATG�AG�AUS�AU�AUT�AT�AZE�AZ�BDI�BI�BEL�BE�BEN�BJ�BFA�BF�BGD�BD�BGR�BG�BHR�BH�BHS�BS�BIH�BA�BLR�BY�BLZ�BZ�BMU�BM�BOL�BO�BRA�BR�BRB�BB�BRN�BN�BTN�BT�BVT�BV�BWA�BW�CAF�CF�CAN�CA�CCK�CC�CHE�CH�CHL�CL�CHN�CN�CMR�CM�COD�CD�COG�CG�COK�CK�COL�CO�COM�KM�CPV�CV�CRI�CR�CUB�CU�CXR�CX�CYM�KY�CYP�CY�CZE�CZ�DEU�DE�DJI�DJ�DMA�DM�DNK�DK�DOM�DO�DZA�DZ�ECU�EC�EGY�EG�ERI�ER�ESH�EH�ESP�ES�EST�EE�ETH�ET�FIN�FI�FJI�FJ�FLK�FK�FRA�FR�FRO�FO�FSM�FM�GAB�GA�GBR�GB�GEO�GE�GGY�GG�GHA�GH�GIB�GI�GIN�GN�GLP�GP�GMB�GM�GNB�GW�GNQ�GQ�GRC�GR�GRD�GD�GRL�GL�GTM�GT�GUF�GF�GUM�GU�GUY�GY�HKG�HK�HMD�HM�HND�HN�HRV�HR�HTI�HT�HUN�HU�IDN�ID�IMN�IM�IND�IN�IOT�IO�IRL�IE�IRN�IR�IRQ�IQ�ISL�IS�ISR�IL�ITA�IT�JAM�JM�JEY�JE�JOR�JO�JPN�JP�KAZ�KZ�KEN�KE�KGZ�KG�KHM�KH�KIR�KI�KNA�KN�KOR�KR�KWT�KW�LAO�LA�LBN�LB�LBR�LR�LBY�LY�LCA�LC�LIE�LI�LKA�LK�LSO�LS�LTU�LT�LUX�LU�LVA�LV�MAC�MO�MAR�MA�MCO�MC�MDA�MD�MDG�MG�MDV�MV�MEX�MX�MHL�MH�MKD�MK�MLI�ML�MLT�MT�MMR�MM�MNE�ME�MNG�MN�MNP�MP�MOZ�MZ�MRT�MR�MSR�MS�MTQ�MQ�MUS�MU�MWI�MW�MYS�MY�MYT�YT�NAM�NA�NCL�NC�NER�NE�NFK�NF�NGA�NG�NIC�NI�NIU�NU�NLD�NL�NOR�NO�NPL�NP�NRU�NR�NZL�NZ�OMN�OM�PAK�PK�PAN�PA�PCN�PN�PER�PE�PHL�PH�PLW�PW�PNG�PG�POL�PL�PRI�PR�PRK�KP�PRT�PT�PRY�PY�PSE�PS�PYF�PF�QAT�QA�REU�RE�ROU�RO�RUS�RU�RWA�RW�SAU�SA�SDN�SD�SEN�SN�SGP�SG�SGS�GS�SHN�SH�SJM�SJ�SLB�SB�SLE�SL�SLV�SV�SMR�SM�SOM�SO�SPM�PM�SRB�RS�STP�ST�SUR�SR�SVK�SK�SVN�SI�SWE�SE�SWZ�SZ�SYC�SC�SYR�SY�TCA�TC�TCD�TD�TGO�TG�THA�TH�TJK�TJ�TKL�TK�TKM�TM�TLS�TL�TON�TO�TTO�TT�TUN�TN�TUR�TR�TUV�TV�TWN�TW�TZA�TZ�UGA�UG�UKR�UA�UMI�UM�URY�UY�USA�US�UZB�UZ�VAT�VA�VCT�VC�VEN�VE�VGB�VG�VIR�VI�VNM�VN�VUT�VU�WLF�WF�WSM�WS�YE�ZA�ZM�ZW)�YEM�ZAF�ZMB�ZWEz+297z+93z+244z+1-264z+355z+376z+599z+971z+54z+374z+1-684z+672z+1-268z+61z+43z+994z+257z+32z+229z+226z+880z+359z+973z+1-242z+387z+375z+501z+1-441z+591z+55z+1-246z+673z+975z+267z+236z+1z+41z+56z+86z+237z+243z+242z+682z+57z+269z+238z+506z+53z+1-345z+357z+420z+49z+253z+1-767z+45z+1-809z+213z+593z+20z+291z+212z+34z+372z+251z+358z+679z+500z+33z+298z+691z+241z+44z+995z+44-1481z+233z+350z+224z+590z+220z+245z+240z+30z+1-473z+299z+502z+594z+1-671z+592z+852z+504z+385z+509z+36z+62z+44-1624z+91z+246z+353z+98z+964z+354z+972z+39z+1-876z+44-1534z+962z+81z+7z+254z+996z+855z+686z+1-869z+82z+965z+856z+961z+231z+218z+1-758z+423z+94z+266z+370z+352z+371z+853z+377z+373z+261z+960z+52z+692z+389z+223z+356z+95z+382z+976z+1-670z+258z+222z+1-664z+596z+230z+265z+60z+262z+264z+687z+227z+234z+505z+683z+31z+47z+977z+674z+64z+968z+92z+507z+51z+63z+680z+675z+48z+1-787z+850z+351z+595z+970z+689z+974z+40z+250z+966z+249z+221z+65z+290z+677z+232z+503z+378z+252z+508z+381z+239z+597z+421z+386z+46z+268z+248z+963z+1-649z+235z+228z+66z+992z+690z+993z+670z+676z+1-868z+216z+90z+688z+886z+255z+256z+380z+598z+998z+379z+1-784z+58z+1-284z+1-340z+84z+678z+681z+685r� z+967r� z+27r� z+260r� z+263>� �004�008�010�012�016�020�024�028�031�032�036�040�044�048�050�051�052�056�060�064�068�070�072�074�076�084�086�090�092�096�100�104�108�112�116�120�124�132�136�140�144�148�152�156�158�162�166�170�174�175�178�180�184�188�191�192�196�203�204�208�212�214�218�222�226�231�232�233�234�238�239�242�246�248�250�254�258�260�262�266�268�270�275�276�288�292�296�300�304�308�312�316�320�324�328�332�334�340�344�348�352�356�360�364�368�372�376�380�384�388�392�398�400�404�408�410�414�417�418�422�426�428�430�434�438�440�442�446�450�454�458�462�466�470�474�478�480�484�492�496�498�499�500�504�508�512�516�520�524�528�531�533�534�535�540�548�554�558�562�566�570�574�578�580�581�583�584�585�586�591�598�600�604�608�612�616�620�624�626�630�634�638�642�643�646�652�654�659�660�662�663�666�670�674�678�682�686�688�690�694�702�703�704�705�706�710�716�724�728�729�732�740�744�748�752�756�760�762�764�768�772�776�780�784�788�792�795�796�798�800�804�807�818�826�831�832�833�834�840�850�854�858�860�862�876�882�887�894>� �AED�AFN�ALL�AMD�ANG�AOA�ARS�AUD�AWG�AZN�BAM�BBD�BDT�BGN�BHD�BIF�BMD�BND�BOB�BOV�BRL�BSDrE �BWP�BYN�BZD�CAD�CDFrQ �CHF�CHW�CKD�CLF�CLP�CNY�COP�CRC�CUC�CUP�CVE�CZK�DJF�DKK�DOP�DZD�EGP�ERN�ETB�EUR�FJD�FKP�GBP�GEL�GHS�GIP�GMD�GNF�GTQ�GYD�HKD�HNL�HRK�HTG�HUF�IDR�IEP�ILS�INR�IQD�IRR�ISK�JMD�JOD�JPY�KES�KGS�KHR�KID�KMF�KPW�KRW�KWD�KYD�KZT�LAK�LBP�LKR�LRD�LSL�LYD�MAD�MDL�MGAr �MMK�MNT�MOP�MRU�MUR�MVR�MWK�MXN�MYR�MZN�NAD�NGN�NIO�NOK�NPR�NZD�OMR�PAB�PEN�PGK�PHP�PKR�PLN�PYG�QAR�RON�RSD�RUB�RWF�SAR�SBD�SCR�SDG�SEK�SGD�SHP�SLL�SOS�SRD�SSP�STN�SVC�SYP�SZL�THB�TJS�TMT�TND�TOP�TRY�TTD�TWD�TZS�UAH�UGX�USD�UYU�UZS�VED�VES�VND�VUV�WST�XAF�XCD�XDR�XOF�XPF�YER�ZAR�ZMW�ZWL>* � ƒ� ֏� ؋� ૱� ௹� ฿� ៛� ₡� ₣� ₦� ₩� ₪� ₫� €� ₭� ₮� ₱� ₲� ₴� ₵� ₸� ₹� ₺� ₼� ₽� ₾� ₿� 元� 円� 圆� 圓� ꠸� ﷼� रू� රු� ⃀৳�Rs� ¢� £� ¤� ¥�$� format_typec C s8 | � � rdS | �� rt| �dkrdS t| �dkrdS dS )z!Returns the type of country code.�numeric� �alpha2� �alpha3�invalid)� isdecimal�isalpha�len)r� � r� �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/country.py�_get_code_type� s r� �valuec C s | sdS | t t�� �v S )a� Validates given calling code. This performs country's calling code validation. Examples: >>> calling_code('+91') # Output: True >>> calling_code('-31') # Output: ValidationError(func=calling_code, args={'value': '-31'}) Args: value: Country's calling code string to validate. Returns: (Literal[True]): If `value` is a valid calling code. (ValidationError): If `value` is an invalid calling code. F)�set�_calling_codes�values)r� r� r� r� � calling_code� s r� �autoF)� iso_format� ignore_caser� r� c C s� | sdS dt | � k rdk sdS dS |dkr"t| � }dkr"dS |dkr:|r2| �� tt�� �v S | tt�� �v S |dkrJ|rF| �� tv S | tv S |dkrR| tv S dS ) a� Validates given country code. This performs a case-sensitive [ISO 3166][1] country code validation. [1]: https://www.iso.org/iso-3166-country-codes.html Examples: >>> country_code('GB', iso_format='alpha3') # Output: False >>> country_code('USA') # Output: True >>> country_code('840', iso_format='numeric') # Output: True >>> country_code('iN', iso_format='alpha2') # Output: False >>> country_code('ZWE', iso_format='alpha3') # Output: True Args: value: Country code string to validate. iso_format: ISO format to be used. Available options are: `auto`, `alpha2`, `alpha3` and `numeric`. ignore_case: Enable/Disable case-sensitive matching. Returns: (Literal[True]): If `value` is a valid country code. (ValidationError): If `value` is an invalid country code. F� � r� r� r� r� r� )r� r� �upperr� �_alpha3_to_alpha2r� �_numeric)r� r� r� r� r� r� � country_code s" !����r� T)� skip_symbolsr� r� c C s@ | sdS |s | t v r dS t| �dkrdS |r | �� tv S | tv S )a� Validates given currency code. This performs [ISO 4217][1] currency code/symbol validation. [1]: https://www.iso.org/iso-4217-currency-codes.html Examples: >>> currency('USD') # Output: True >>> currency('ZWX') # Output: ValidationError(func=currency, args={'value': 'ZWX'}) Args: value: Currency code/symbol string to validate. skip_symbols: Skip currency symbol validation. ignore_case: Enable/Disable case-sensitive matching. Returns: (Literal[True]): If `value` is a valid currency code. (ValidationError): If `value` is an invalid currency code. FTr� )�_currency_symbolsr� r� �_currency_iso4217)r� r� r� r� r� r� �currency@ s r� N)�__doc__�validators.utilsr r� r� r� r� r� �strr� r� �boolr� r� r� r� r� r� �<module> s� ������������������������������������ � � � � � � � � � � � � � � � � � � ������������������������������������������������������ � � � � � � � � � � � �"�"�"�"�"�"�"�#�#�#�#�%�%�%�%�%�%�%�&�&�&�&�&�&�&�'�'�'�'�'�'�'�(�(�*�*�*�*�*�*�*�+�+�+�+�+�-�/�/�/�/�/�/�/�0�0�0�0�0�0�0�2�4�4�4�4�6�6�6�6�6�6�6�7�7�7�7�7�7�7�8�8�8�8�8�8�8�9�;�;�;�;�;�;�;�<�<�<�<�<�<�<�=�?�?�?�?�?�?�A�A�A�A�A�A�A�C�C�E �I��������������������������������� � � � � � � � � � � � � � � � � � � ��������������������������������������� � � � � � � � � � � � � � � � �!�!�!�!�#�#�#�#�#�#�$�$�&�&�&�&�&�&�'�'�'�'�'�)�)�)�)�)�)�*�*�*�*�*�*�+�+�+�+�+�,�,�,�,�,�,�.�.�.�.�.�.�/�/�/�/�/�/�1�3�3�3�3�3�3�4�4�4�4�4�4�5�5�7�9�9�9�9�;�;�;�;�;�;�<�<�<�<�<�<�=�=�=�=�=�=�>�>�>�@�@�@�@�@�@�A�A�A�A�A�A�B�B�B�D�D�D�D�D�D�F�F�F�F�F�G�G�I�I�K�M�M�M� O ! 056 __pycache__/finance.cpython-310.pyc 0000644 00000006324 15030212475 0013064 0 ustar 00 o �h� � @ sf d Z ddlmZ defdd�Zdefdd�Zedefd d��Zedefd d ��Zedefd d ��ZdS )zFinance.� )� validator�cusipc C s� d\}}t d�D ]g}| | }|dkr |dkr t|�td� }n>|dkr2|dkr2dt|� td� }n+|dkrE|d krEdt|� td� }n|d krLd }n|d krSd }n |dkrZd}n dS |d@ re||7 }||d |d }q|d dkS )N�� N� �0�9�A�Z� �a�z�*�$ �@�% �#�& Fr r ��range�ord)r �check�val�idx�c� r �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/finance.py�_cusip_checksum s( r �valuec C s� d\}}t d�D ]L}| | }|dkr#|dkr#|dkr#t|�td� }n)|dkr6|dkr6dt|� td� }n|d krI|d krIdt|� td � }n d S |d@ rT||7 }q|d d kS ) Nr � r r r r r r r r Fr r )r r r r r r r r �_isin_checksum" s � r c C � t | �dko t| �S )a� Return whether or not given value is a valid CUSIP. Checks if the value is a valid [CUSIP][1]. [1]: https://en.wikipedia.org/wiki/CUSIP Examples: >>> cusip('037833DP2') True >>> cusip('037833DP3') ValidationFailure(func=cusip, ...) Args: value: CUSIP string to validate. Returns: (Literal[True]): If `value` is a valid CUSIP string. (ValidationError): If `value` is an invalid CUSIP string. r )�lenr �r r r r r 6 � c C r! )a� Return whether or not given value is a valid ISIN. Checks if the value is a valid [ISIN][1]. [1]: https://en.wikipedia.org/wiki/International_Securities_Identification_Number Examples: >>> isin('037833DP2') True >>> isin('037833DP3') ValidationFailure(func=isin, ...) Args: value: ISIN string to validate. Returns: (Literal[True]): If `value` is a valid ISIN string. (ValidationError): If `value` is an invalid ISIN string. r )r" r r# r r r �isinM r$ r% c C s� t | �dkrdS g d�}d}td�D ]>}| | }|dv r dS d}|dkr2|dkr2t|�td� }n|d krE|d krEd t|� td � }n dS |||| 7 }q|d dkS ) a� Return whether or not given value is a valid SEDOL. Checks if the value is a valid [SEDOL][1]. [1]: https://en.wikipedia.org/wiki/SEDOL Examples: >>> sedol('2936921') True >>> sedol('29A6922') ValidationFailure(func=sedol, ...) Args: value: SEDOL string to validate. Returns: (Literal[True]): If `value` is a valid SEDOL string. (ValidationError): If `value` is an invalid SEDOL string. � F)r � r r& r' r r r �AEIOUNr r r r r )r" r r )r �weightsr r r r r r r �sedold s r* N) �__doc__�utilsr �strr r r r% r* r r r r �<module> s __pycache__/utils.cpython-310.pyc 0000644 00000006655 15030212475 0012630 0 ustar 00 o �hi � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z m Z m Z G dd� de �Zd e d e f d e d e fd d�Zd e d e f fdd�ZdS )zUtils.� )�wraps)�getfullargspec)�chain)�environ)�Any�Callable�Dictc @ sP e Zd ZdZddedef deeef defdd�Zd d � Z d d � Z d d� Z dS )�ValidationErrorz/Exception class when validation failure occurs.� �function.�arg_dict�messagec C s |r|| _ || _| j�|� dS )z Initialize Validation Failure.N)�reason�func�__dict__�update)�selfr r r � r �C/usr/local/CyberCP/lib/python3.10/site-packages/validators/utils.py�__init__ s zValidationError.__init__c C s, d| j j� d�ddd� | j�� D �� d� S )zRepr Validation Failure.zValidationError(func=z, zargs=c S s i | ] \}}|d kr||�qS �r r )�.0�k�vr r r � <dictcomp> s z,ValidationError.__repr__.<locals>.<dictcomp>�))r �__name__r �items�r r r r �__repr__ s ��zValidationError.__repr__c C s t | �S )zStr Validation Failure.)�reprr r r r �__str__ s zValidationError.__str__c C s dS )zBool Validation Failure.Fr r r r r �__bool__ s zValidationError.__bool__N)r ) r � __module__� __qualname__�__doc__r r r �strr r r! r" r r r r r s ( r r .�args�kwargsc O s6 t ttt �tt| �d |�� ��|��t|�� � �S )zNReturn function's positional and key value arguments as an ordered dictionary.r )�dict�list�zip�fromkeysr r �keysr )r r' r( r r r �_func_args_as_dict% s $ ��r. c s" t � �dtdtf� fdd� �}|S )a� A decorator that makes given function validator. Whenever the given `func` returns `False` this decorator returns `ValidationError` object. Examples: >>> @validator ... def even(value): ... return not (value % 2) >>> even(4) # Output: True >>> even(5) # Output: ValidationError(func=even, args={'value': 5}) Args: func: Function which is to be decorated. Returns: (Callable[..., ValidationError | Literal[True]]): A decorator which returns either `ValidationError` or `Literal[True]`. Raises: (ValidationError): If `r_ve` or `RAISE_VALIDATION_ERROR` is `True` r' r( c s d}d|v r d}|d= t �dd�dkrd}z3|r0� | i |��r"W dS t� t� g| �R i |����� | i |��r:dW S t� t� g| �R i |���W S tttfy� } z+|rgt� t� g| �R i |��t|��|�t� t� g| �R i |��t|��W Y d }~S d }~ww )NF�r_veT�RAISE_VALIDATION_ERROR�False�True)r �getr r. � ValueError� TypeError� UnicodeErrorr& )r' r( �raise_validation_error�expr r r �wrapperI s4 ��� ��.��zvalidator.<locals>.wrapper)r r )r r9 r r r � validator- s r: N)r% � functoolsr �inspectr � itertoolsr �osr �typingr r r � Exceptionr r. r: r r r r �<module> s __pycache__/hashes.cpython-310.pyc 0000644 00000010155 15030212475 0012731 0 ustar 00 o �h� � @ s� d Z ddlZddlmZ edefdd��Zedefdd ��Zedefd d ��Zedefd d ��Zedefdd��Z edefdd��Z dS )zHashes.� N� )� validator�valuec C � | r t �d| t j�S dS )a� Return whether or not given value is a valid MD5 hash. Examples: >>> md5('d41d8cd98f00b204e9800998ecf8427e') # Output: True >>> md5('900zz11') # Output: ValidationError(func=md5, args={'value': '900zz11'}) Args: value: MD5 string to validate. Returns: (Literal[True]): If `value` is a valid MD5 hash. (ValidationError): If `value` is an invalid MD5 hash. z^[0-9a-f]{32}$F��re�match� IGNORECASE�r � r �D/usr/local/CyberCP/lib/python3.10/site-packages/validators/hashes.py�md5 � r c C r )a� Return whether or not given value is a valid SHA1 hash. Examples: >>> sha1('da39a3ee5e6b4b0d3255bfef95601890afd80709') # Output: True >>> sha1('900zz11') # Output: ValidationError(func=sha1, args={'value': '900zz11'}) Args: value: SHA1 string to validate. Returns: (Literal[True]): If `value` is a valid SHA1 hash. (ValidationError): If `value` is an invalid SHA1 hash. z^[0-9a-f]{40}$Fr r r r r �sha1 r r c C r )a� Return whether or not given value is a valid SHA224 hash. Examples: >>> sha224('d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f') # Output: True >>> sha224('900zz11') # Output: ValidationError(func=sha224, args={'value': '900zz11'}) Args: value: SHA224 string to validate. Returns: (Literal[True]): If `value` is a valid SHA224 hash. (ValidationError): If `value` is an invalid SHA224 hash. z^[0-9a-f]{56}$Fr r r r r �sha2244 r r c C r )a Return whether or not given value is a valid SHA256 hash. Examples: >>> sha256( ... 'e3b0c44298fc1c149afbf4c8996fb924' ... '27ae41e4649b934ca495991b7852b855' ... ) # Output: True >>> sha256('900zz11') # Output: ValidationError(func=sha256, args={'value': '900zz11'}) Args: value: SHA256 string to validate. Returns: (Literal[True]): If `value` is a valid SHA256 hash. (ValidationError): If `value` is an invalid SHA256 hash. z^[0-9a-f]{64}$Fr r r r r �sha256I � r c C r )a@ Return whether or not given value is a valid SHA384 hash. Examples: >>> sha384( ... 'cb00753f45a35e8bb5a03d699ac65007272c32ab0eded163' ... '1a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7' ... ) # Output: True >>> sha384('900zz11') # Output: ValidationError(func=sha384, args={'value': '900zz11'}) Args: value: SHA384 string to validate. Returns: (Literal[True]): If `value` is a valid SHA384 hash. (ValidationError): If `value` is an invalid SHA384 hash. z^[0-9a-f]{96}$Fr r r r r �sha384a r r c C r )as Return whether or not given value is a valid SHA512 hash. Examples: >>> sha512( ... 'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce' ... '9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af9' ... '27da3e' ... ) # Output: True >>> sha512('900zz11') # Output: ValidationError(func=sha512, args={'value': '900zz11'}) Args: value: SHA512 string to validate. Returns: (Literal[True]): If `value` is a valid SHA512 hash. (ValidationError): If `value` is an invalid SHA512 hash. z^[0-9a-f]{128}$Fr r r r r �sha512y s r ) �__doc__r �utilsr �strr r r r r r r r r r �<module> s __pycache__/slug.cpython-310.pyc 0000644 00000001715 15030212475 0012432 0 ustar 00 o �h� � @ s. d Z ddlZddlmZ edefdd��ZdS )zSlug.� N� )� validator�valuec C s | rt �d| �S dS )a' Validate whether or not given value is valid slug. Valid slug can contain only lowercase alphanumeric characters and hyphens. It starts and ends with these lowercase alphanumeric characters. Examples: >>> slug('my-slug-2134') # Output: True >>> slug('my.slug') # Output: ValidationError(func=slug, args={'value': 'my.slug'}) Args: value: Slug string to validate. Returns: (Literal[True]): If `value` is a valid slug. (ValidationError): If `value` is an invalid slug. z^[a-z0-9]+(?:-[a-z0-9]+)*$F)�re�match)r � r �B/usr/local/CyberCP/lib/python3.10/site-packages/validators/slug.py�slug s r )�__doc__r �utilsr �strr r r r r �<module> s __pycache__/iban.cpython-310.pyc 0000644 00000002710 15030212475 0012365 0 ustar 00 o �h7 � @ sJ d Z ddlZddlmZ defdd�Zdefd d �Zedefd d ��ZdS ) zIBAN.� N� )� validator�charc C s$ | � � r| S tdt| � td� �S )zA=10, B=11, ..., Z=35.� �A)�isdigit�str�ord)r � r �B/usr/local/CyberCP/lib/python3.10/site-packages/validators/iban.py� _char_value s $r �valuec C s8 | dd� | dd� }t d�dd� |D ���d dkS )z0Check if the value string passes the mod97-test.� N� c s s � | ]}t |�V qd S )N)r )�.0r r r r � <genexpr> s � z _mod_check.<locals>.<genexpr>�a r )�int�join)r � rearrangedr r r � _mod_check s r c C s | rt �d| t j�o t| �S dS )a� Return whether or not given value is a valid IBAN code. Examples: >>> iban('DE29100500001061045672') # Output: True >>> iban('123456') # Output: ValidationError(func=iban, ...) Args: value: IBAN string to validate. Returns: (Literal[True]): If `value` is a valid IBAN code. (ValidationError): If `value` is an invalid IBAN code. z!^[a-z]{2}[0-9]{2}[a-z0-9]{11,30}$F)�re�match� IGNORECASEr )r r r r �iban s ���r )�__doc__r �utilsr r r r r r r r r �<module> s __pycache__/mac_address.cpython-310.pyc 0000644 00000002107 15030212475 0013721 0 ustar 00 o �ha � @ s. d Z ddlZddlmZ edefdd��ZdS )z MAC Address.� N� )� validator�valuec C s | rt �d| �S dS )a} Return whether or not given value is a valid MAC address. This validator is based on [WTForms MacAddress validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L482 Examples: >>> mac_address('01:23:45:67:ab:CD') # Output: True >>> mac_address('00:00:00:00:00') # Output: ValidationError(func=mac_address, args={'value': '00:00:00:00:00'}) Args: value: MAC address string to validate. Returns: (Literal[True]): If `value` is a valid MAC address. (ValidationError): If `value` is an invalid MAC address. z)^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$F)�re�match)r � r �I/usr/local/CyberCP/lib/python3.10/site-packages/validators/mac_address.py� mac_address s r )�__doc__r �utilsr �strr r r r r �<module> s __pycache__/hostname.cpython-310.pyc 0000644 00000007266 15030212475 0013305 0 ustar 00 o �h/ � @ s� d Z ddlmZ ddlZddlmZ ddlmZ ddlmZm Z ddl m Z ed d � �Z ed d � �Z d efdd�Ze ddddddddd�d ededededededee dedefdd ��ZdS ) z Hostname.� )� lru_cacheN)�Optional� )�domain)�ipv4�ipv6)� validatorc C s t �d�S )zPort validation regex.zZ^\:(6553[0-5]|655[0-2][0-9]|65[0-4][0-9]{2}|6[0-4][0-9]{3}|[1-5][0-9]{4}|[1-9][0-9]{0,3})$)�re�compile� r r �F/usr/local/CyberCP/lib/python3.10/site-packages/validators/hostname.py� _port_regex s �r c C s t �dt j�S )z!Simple hostname validation regex.z1^(?!-)[a-z0-9](?:[a-z0-9-]{0,59}[a-z0-9])?(?<!-)$)r r � IGNORECASEr r r r �_simple_hostname_regex s r �valuec C sx | � d�dkr | �dd�\}}t� �d|� ��r |�d��d�S | � d�dkr:| �dd�\}}t� �d|� ��r:|S dS )z&Returns host segment if port is valid.z]:r �:�[�]N)�count�rsplitr �match�lstrip�rstrip)r �host_seg�port_segr r r �_port_validator s r FT)�skip_ipv6_addr�skip_ipv4_addr� may_have_port� maybe_simple� consider_tld�private�rfc_1034�rfc_2782r r r r r r! r" r# c C s� | sdS |r3t | � } r3|rt� �| �ndp2t| |||d�p2|r"dnt| d|d�p2|r-dS t| dd�S |r;t� �| �ndpYt| |||d�pY|rIdnt| d|d�pY|rTdS t| dd�S )a� Return whether or not given value is a valid hostname. Examples: >>> hostname("ubuntu-pc:443") # Output: True >>> hostname("this-pc") # Output: True >>> hostname("xn----gtbspbbmkef.xn--p1ai:65535") # Output: True >>> hostname("_example.com") # Output: True >>> hostname("123.5.77.88:31000") # Output: True >>> hostname("12.12.12.12") # Output: True >>> hostname("[::1]:22") # Output: True >>> hostname("dead:beef:0:0:0:0000:42:1") # Output: True >>> hostname("[0:0:0:0:0:ffff:1.2.3.4]:-65538") # Output: ValidationError(func=hostname, ...) >>> hostname("[0:&:b:c:@:e:f::]:9999") # Output: ValidationError(func=hostname, ...) Args: value: Hostname string to validate. skip_ipv6_addr: When hostname string cannot be an IPv6 address. skip_ipv4_addr: When hostname string cannot be an IPv4 address. may_have_port: Hostname string may contain port number. maybe_simple: Hostname string maybe only hyphens and alpha-numerals. consider_tld: Restrict domain to TLDs allowed by IANA. private: Embedded IP address is public if `False`, private/local if `True`. rfc_1034: Allow trailing dot in domain/host name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain/Host name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid hostname. (ValidationError): If `value` is an invalid hostname. F)r r" r# )�cidrr! )r$ )r r r r r r ) r r r r r r r! r" r# r r r r �hostname1 s* @��� ���� �r% )�__doc__� functoolsr r �typingr r � ip_addressr r �utilsr r r �strr �boolr% r r r r �<module> sP ������� � � � __pycache__/encoding.cpython-310.pyc 0000644 00000005314 15030212475 0013245 0 ustar 00 o �h� � @ sd d Z ddlZddlmZ edefdd��Zedefdd ��Zedefd d ��Zedefd d ��ZdS )z Encoding.� N� )� validator�valuec C � | rt �d| �S dS )a� Return whether or not given value is a valid base16 encoding. Examples: >>> base16('a3f4b2') # Output: True >>> base16('a3f4Z1') # Output: ValidationError(func=base16, args={'value': 'a3f4Z1'}) Args: value: base16 string to validate. Returns: (Literal[True]): If `value` is a valid base16 encoding. (ValidationError): If `value` is an invalid base16 encoding. z^[0-9A-Fa-f]+$F��re�match�r � r �F/usr/local/CyberCP/lib/python3.10/site-packages/validators/encoding.py�base16 � r c C r )a� Return whether or not given value is a valid base32 encoding. Examples: >>> base32('MFZWIZLTOQ======') # Output: True >>> base32('MfZW3zLT9Q======') # Output: ValidationError(func=base32, args={'value': 'MfZW3zLT9Q======'}) Args: value: base32 string to validate. Returns: (Literal[True]): If `value` is a valid base32 encoding. (ValidationError): If `value` is an invalid base32 encoding. z ^[A-Z2-7]+=*$Fr r r r r �base32 r r c C r )a� Return whether or not given value is a valid base58 encoding. Examples: >>> base58('14pq6y9H2DLGahPsM4s7ugsNSD2uxpHsJx') # Output: True >>> base58('cUSECm5YzcXJwP') # Output: ValidationError(func=base58, args={'value': 'cUSECm5YzcXJwP'}) Args: value: base58 string to validate. Returns: (Literal[True]): If `value` is a valid base58 encoding. (ValidationError): If `value` is an invalid base58 encoding. z^[1-9A-HJ-NP-Za-km-z]+$Fr r r r r �base584 r r c C r )a� Return whether or not given value is a valid base64 encoding. Examples: >>> base64('Y2hhcmFjdGVyIHNldA==') # Output: True >>> base64('cUSECm5YzcXJwP') # Output: ValidationError(func=base64, args={'value': 'cUSECm5YzcXJwP'}) Args: value: base64 string to validate. Returns: (Literal[True]): If `value` is a valid base64 encoding. (ValidationError): If `value` is an invalid base64 encoding. z@^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$Fr r r r r �base64I s ���r ) �__doc__r �utilsr �strr r r r r r r r �<module> s __pycache__/url.cpython-310.pyc 0000644 00000013206 15030212475 0012260 0 ustar 00 o �h0 � @ s6 d Z ddlmZ ddlZddlmZ ddlmZmZm Z ddl m Z ddl m Z ed d � �Z ed d � �Zd efdd�Zd edefdd�Zd efdd�Zd ededededededee dedefd d �Zd ed ed ed!efd"d#�Ze d$d$d%d$d%d$dd$d$d&� d ededededed!ededee dedefd'd(��ZdS ))zURL.� )� lru_cacheN)�Optional)�parse_qs�unquote�urlsplit� )�hostname)� validatorc C � t �dt j�S )Nz�(^[\u0100-\u017F\u0180-\u024F]|[-!#$%&'*+/=?^_`{}|~0-9a-z]+(\.[-!#$%&'*+/=?^_`{}|~0-9a-z]+)*$|^([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\011.])*$)��re�compile� IGNORECASE� r r �A/usr/local/CyberCP/lib/python3.10/site-packages/validators/url.py�_username_regex s �r c C r )Nz�^[\/a-z0-9\-\.\_\~\!\$\&\'\(\)\*\+\,\;\=\:\@\%\U0001F300-\U0001F5FF\U0001F600-\U0001F64F\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$r r r r r � _path_regex s �r �valuec C s | r| dv S dS )zValidate scheme.> �ftp�git�irc�ssh�ftps�http�rtmp�rtsp�sftp�https�rtmps�telnetFr )r r r r �_validate_scheme* s ��� �r �skip_ipv6_addrc C s |p| � d�dk p| �d� S )zConfirm skip IPv6 check.�:� �[)�count� startswith)r r! r r r �_confirm_ipv6_skip; s r' c sp | sdS | � d� }dkrt� �t| ��S |dk r t� �| �S | �dd�\}� t� �|�o7t� fdd�dD ��S )z Validate authentication segment.Tr" r c 3 s � | ]}|� vV qd S )Nr )�.0� char_to_avoid��passwordr r � <genexpr>K s � �z)_validate_auth_segment.<locals>.<genexpr>)�/�?�#�@)r% r �matchr �rsplit�all)r � colon_count�usernamer r* r �_validate_auth_segment@ s �r6 �skip_ipv4_addr� may_have_port� simple_host� consider_tld�private�rfc_1034�rfc_2782c C s� | r | � d�dkr dS | � d�dk r5tt| |�s d| v r | n | �d��ddd�t| |�|||||||d� S | �dd�\} } tt| |�sGd| v rI| n | �d��ddd�t| |�|||||||d� oct| �S ) zValidate netloc.r0 r Fz]:r$ �]� )r! r7 r8 � maybe_simpler: r; r< r= )r% r r' �lstrip�replacer2 r6 ) r r! r7 r8 r9 r: r; r< r= � basic_auth�hostr r r �_validate_netlocP sH �������rE �path�query�fragment� strict_queryc C s� d}| r|t t� �| ��M }z|r#t||dd�r#t||dd�r#|dM }W n ty9 |r7t||d�r7|dM }Y nw |rH|t t�d|tj��M }|S )z"Validate path query and fragments.T�&)�strict_parsing� separator�;)rK z [0-9a-z?/:@\-._~%!$&'()*+,;=]*)�boolr r1 r � TypeErrorr � fullmatchr )rF rG rH rI �optional_segmentsr r r �_validate_optionals� s, � � �� ���rR FT) r! r7 r8 r9 rI r: r; r< r= c C sn | rt �d| �r dS z t| �\} } } } }W n ty Y dS w t| �o6t| |||||||| � o6t| | ||�S )a� Return whether or not given value is a valid URL. This validator was originally inspired from [URL validator of dperini][1]. The following diagram is from [urlly][2]:: foo://admin:hunter1@example.com:8042/over/there?name=ferret#nose \_/ \___/ \_____/ \_________/ \__/\_________/ \_________/ \__/ | | | | | | | | scheme username password hostname port path query fragment [1]: https://gist.github.com/dperini/729294 [2]: https://github.com/treeform/urlly Examples: >>> url('http://duck.com') # Output: True >>> url('ftp://foobar.dk') # Output: True >>> url('http://10.0.0.1') # Output: True >>> url('http://example.com/">user@example.com') # Output: ValidationError(func=url, ...) Args: value: URL string to validate. skip_ipv6_addr: When URL string cannot contain an IPv6 address. skip_ipv4_addr: When URL string cannot contain an IPv4 address. may_have_port: URL string may contain port number. simple_host: URL string maybe only hyphens and alpha-numerals. strict_query: Fail validation on query string parsing error. consider_tld: Restrict domain to TLDs allowed by IANA. private: Embedded IP address is public if `False`, private/local if `True`. rfc_1034: Allow trailing dot in domain/host name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain/Host name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid url. (ValidationError): If `value` is an invalid url. z\sF)r �searchr � ValueErrorr rE rR )r r! r7 r8 r9 rI r: r; r< r= �scheme�netlocrF rG rH r r r �url� s, C ��� �rW )�__doc__� functoolsr r �typingr � urllib.parser r r r �utilsr r r �strr rN r' r6 rE rR rW r r r r �<module> s� �������� �0������� � � � � url.py 0000644 00000016460 15030212475 0005726 0 ustar 00 """URL.""" # standard from functools import lru_cache import re from typing import Optional from urllib.parse import parse_qs, unquote, urlsplit # local from .hostname import hostname from .utils import validator @lru_cache def _username_regex(): return re.compile( # extended latin r"(^[\u0100-\u017F\u0180-\u024F]" # dot-atom + r"|[-!#$%&'*+/=?^_`{}|~0-9a-z]+(\.[-!#$%&'*+/=?^_`{}|~0-9a-z]+)*$" # non-quoted-string + r"|^([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\011.])*$)", re.IGNORECASE, ) @lru_cache def _path_regex(): return re.compile( # allowed symbols r"^[\/a-z0-9\-\.\_\~\!\$\&\'\(\)\*\+\,\;\=\:\@\%" # symbols / pictographs + r"\U0001F300-\U0001F5FF" # emoticons / emoji + r"\U0001F600-\U0001F64F" # multilingual unicode ranges + r"\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$", re.IGNORECASE, ) def _validate_scheme(value: str): """Validate scheme.""" # More schemes will be considered later. return ( value # fmt: off in { "ftp", "ftps", "git", "http", "https", "irc", "rtmp", "rtmps", "rtsp", "sftp", "ssh", "telnet", } # fmt: on if value else False ) def _confirm_ipv6_skip(value: str, skip_ipv6_addr: bool): """Confirm skip IPv6 check.""" return skip_ipv6_addr or value.count(":") < 2 or not value.startswith("[") def _validate_auth_segment(value: str): """Validate authentication segment.""" if not value: return True if (colon_count := value.count(":")) > 1: # everything before @ is then considered as a username # this is a bad practice, but syntactically valid URL return _username_regex().match(unquote(value)) if colon_count < 1: return _username_regex().match(value) username, password = value.rsplit(":", 1) return _username_regex().match(username) and all( char_to_avoid not in password for char_to_avoid in ("/", "?", "#", "@") ) def _validate_netloc( value: str, skip_ipv6_addr: bool, skip_ipv4_addr: bool, may_have_port: bool, simple_host: bool, consider_tld: bool, private: Optional[bool], rfc_1034: bool, rfc_2782: bool, ): """Validate netloc.""" if not value or value.count("@") > 1: return False if value.count("@") < 1: return hostname( ( value if _confirm_ipv6_skip(value, skip_ipv6_addr) or "]:" in value else value.lstrip("[").replace("]", "", 1) ), skip_ipv6_addr=_confirm_ipv6_skip(value, skip_ipv6_addr), skip_ipv4_addr=skip_ipv4_addr, may_have_port=may_have_port, maybe_simple=simple_host, consider_tld=consider_tld, private=private, rfc_1034=rfc_1034, rfc_2782=rfc_2782, ) basic_auth, host = value.rsplit("@", 1) return hostname( ( host if _confirm_ipv6_skip(host, skip_ipv6_addr) or "]:" in value else host.lstrip("[").replace("]", "", 1) ), skip_ipv6_addr=_confirm_ipv6_skip(host, skip_ipv6_addr), skip_ipv4_addr=skip_ipv4_addr, may_have_port=may_have_port, maybe_simple=simple_host, consider_tld=consider_tld, private=private, rfc_1034=rfc_1034, rfc_2782=rfc_2782, ) and _validate_auth_segment(basic_auth) def _validate_optionals(path: str, query: str, fragment: str, strict_query: bool): """Validate path query and fragments.""" optional_segments = True if path: optional_segments &= bool(_path_regex().match(path)) try: if ( query # ref: https://github.com/python/cpython/issues/117109 and parse_qs(query, strict_parsing=strict_query, separator="&") and parse_qs(query, strict_parsing=strict_query, separator=";") ): optional_segments &= True except TypeError: # for Python < v3.9.2 (official v3.10) if query and parse_qs(query, strict_parsing=strict_query): optional_segments &= True if fragment: # See RFC3986 Section 3.5 Fragment for allowed characters optional_segments &= bool( re.fullmatch(r"[0-9a-z?/:@\-._~%!$&'()*+,;=]*", fragment, re.IGNORECASE) ) return optional_segments @validator def url( value: str, /, *, skip_ipv6_addr: bool = False, skip_ipv4_addr: bool = False, may_have_port: bool = True, simple_host: bool = False, strict_query: bool = True, consider_tld: bool = False, private: Optional[bool] = None, # only for ip-addresses rfc_1034: bool = False, rfc_2782: bool = False, ): r"""Return whether or not given value is a valid URL. This validator was originally inspired from [URL validator of dperini][1]. The following diagram is from [urlly][2]:: foo://admin:hunter1@example.com:8042/over/there?name=ferret#nose \_/ \___/ \_____/ \_________/ \__/\_________/ \_________/ \__/ | | | | | | | | scheme username password hostname port path query fragment [1]: https://gist.github.com/dperini/729294 [2]: https://github.com/treeform/urlly Examples: >>> url('http://duck.com') # Output: True >>> url('ftp://foobar.dk') # Output: True >>> url('http://10.0.0.1') # Output: True >>> url('http://example.com/">user@example.com') # Output: ValidationError(func=url, ...) Args: value: URL string to validate. skip_ipv6_addr: When URL string cannot contain an IPv6 address. skip_ipv4_addr: When URL string cannot contain an IPv4 address. may_have_port: URL string may contain port number. simple_host: URL string maybe only hyphens and alpha-numerals. strict_query: Fail validation on query string parsing error. consider_tld: Restrict domain to TLDs allowed by IANA. private: Embedded IP address is public if `False`, private/local if `True`. rfc_1034: Allow trailing dot in domain/host name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain/Host name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid url. (ValidationError): If `value` is an invalid url. """ if not value or re.search(r"\s", value): # url must not contain any white # spaces, they must be encoded return False try: scheme, netloc, path, query, fragment = urlsplit(value) except ValueError: return False return ( _validate_scheme(scheme) and _validate_netloc( netloc, skip_ipv6_addr, skip_ipv4_addr, may_have_port, simple_host, consider_tld, private, rfc_1034, rfc_2782, ) and _validate_optionals(path, query, fragment, strict_query) ) _extremes.py 0000644 00000002016 15030212475 0007107 0 ustar 00 """Extremes.""" # standard from functools import total_ordering from typing import Any @total_ordering class AbsMax: """An object that is greater than any other object (except itself). Inspired by https://pypi.python.org/pypi/Extremes. Examples: >>> from sys import maxint >>> AbsMax > AbsMin # Output: True >>> AbsMax > maxint # Output: True >>> AbsMax > 99999999999999999 # Output: True """ def __ge__(self, other: Any): """GreaterThanOrEqual.""" return other is not AbsMax @total_ordering class AbsMin: """An object that is less than any other object (except itself). Inspired by https://pypi.python.org/pypi/Extremes. Examples: >>> from sys import maxint >>> AbsMin < -maxint # Output: True >>> AbsMin < None # Output: True >>> AbsMin < '' # Output: True """ def __le__(self, other: Any): """LessThanOrEqual.""" return other is not AbsMin uuid.py 0000644 00000002050 15030212475 0006060 0 ustar 00 """UUID.""" # standard import re from typing import Union from uuid import UUID # local from .utils import validator @validator def uuid(value: Union[str, UUID], /): """Return whether or not given value is a valid UUID-v4 string. This validator is based on [WTForms UUID validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L539 Examples: >>> uuid('2bc1c94f-0deb-43e9-92a1-4775189ec9f8') # Output: True >>> uuid('2bc1c94f 0deb-43e9-92a1-4775189ec9f8') # Output: ValidationError(func=uuid, ...) Args: value: UUID string or object to validate. Returns: (Literal[True]): If `value` is a valid UUID. (ValidationError): If `value` is an invalid UUID. """ if not value: return False if isinstance(value, UUID): return True try: return UUID(value) or re.match( r"^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$", value ) except ValueError: return False py.typed 0000644 00000000000 15030212475 0006230 0 ustar 00 i18n/fr.py 0000644 00000007515 15030212475 0006313 0 ustar 00 """France.""" # standard from functools import lru_cache import re import typing # local from validators.utils import validator @lru_cache def _ssn_pattern(): """SSN Pattern.""" return re.compile( r"^([1,2])" # gender (1=M, 2=F) r"\s(\d{2})" # year of birth r"\s(0[1-9]|1[0-2])" # month of birth r"\s(\d{2,3}|2[A,B])" # department of birth r"\s(\d{2,3})" # town of birth r"\s(\d{3})" # registration number r"(?:\s(\d{2}))?$", # control key (may or may not be provided) re.VERBOSE, ) @validator def fr_department(value: typing.Union[str, int]): """Validate a french department number. Examples: >>> fr_department(20) # can be an integer # Output: True >>> fr_department("20") # Output: True >>> fr_department("971") # Guadeloupe # Output: True >>> fr_department("00") # Output: ValidationError(func=fr_department, args=...) >>> fr_department('2A') # Corsica # Output: True >>> fr_department('2B') # Output: True >>> fr_department('2C') # Output: ValidationError(func=fr_department, args=...) Args: value: French department number to validate. Returns: (Literal[True]): If `value` is a valid french department number. (ValidationError): If `value` is an invalid french department number. """ if not value: return False if isinstance(value, str): if value in ("2A", "2B"): # Corsica return True try: value = int(value) except ValueError: return False return 1 <= value <= 19 or 21 <= value <= 95 or 971 <= value <= 976 # Overseas departments @validator def fr_ssn(value: str): """Validate a french Social Security Number. Each french citizen has a distinct Social Security Number. For more information see [French Social Security Number][1] (sadly unavailable in english). [1]: https://fr.wikipedia.org/wiki/Num%C3%A9ro_de_s%C3%A9curit%C3%A9_sociale_en_France Examples: >>> fr_ssn('1 84 12 76 451 089 46') # Output: True >>> fr_ssn('1 84 12 76 451 089') # control key is optional # Output: True >>> fr_ssn('3 84 12 76 451 089 46') # wrong gender number # Output: ValidationError(func=fr_ssn, args=...) >>> fr_ssn('1 84 12 76 451 089 47') # wrong control key # Output: ValidationError(func=fr_ssn, args=...) Args: value: French Social Security Number string to validate. Returns: (Literal[True]): If `value` is a valid french Social Security Number. (ValidationError): If `value` is an invalid french Social Security Number. """ if not value: return False matched = re.match(_ssn_pattern(), value) if not matched: return False groups = list(matched.groups()) control_key = groups[-1] department = groups[3] if department != "99" and not fr_department(department): # 99 stands for foreign born people return False if control_key is None: # no control key provided, no additional check needed return True if len(department) == len(groups[4]): # if the department number is 3 digits long (overseas departments), # the town number must be 2 digits long # and vice versa return False if department in ("2A", "2B"): # Corsica's department numbers are not in the same range as the others # thus 2A and 2B are replaced by 19 and 18 respectively to compute the control key groups[3] = "19" if department == "2A" else "18" # the control key is valid if it is equal to 97 - (the first 13 digits modulo 97) digits = int("".join(groups[:-1])) return int(control_key) == (97 - (digits % 97)) i18n/__pycache__/ind.cpython-310.pyc 0000644 00000002607 15030212475 0013012 0 ustar 00 o �hy � @ s@ d Z ddlZddlmZ edefdd��Zedefdd��ZdS ) zIndia.� N)� validator�valuec C � t �d| �S )a� Validate an indian aadhar card number. Examples: >>> ind_aadhar('3675 9834 6015') True >>> ind_aadhar('3675 ABVC 2133') ValidationFailure(func=aadhar, args={'value': '3675 ABVC 2133'}) Args: value: Aadhar card number string to validate. Returns: (Literal[True]): If `value` is a valid aadhar card number. (ValidationError): If `value` is an invalid aadhar card number. z ^[2-9]{1}\d{3}\s\d{4}\s\d{4}$��re�match�r � r �F/usr/local/CyberCP/lib/python3.10/site-packages/validators/i18n/ind.py� ind_aadhar � r c C r )a� Validate a pan card number. Examples: >>> ind_pan('ABCDE9999K') True >>> ind_pan('ABC5d7896B') ValidationFailure(func=pan, args={'value': 'ABC5d7896B'}) Args: value: PAN card number string to validate. Returns: (Literal[True]): If `value` is a valid PAN card number. (ValidationError): If `value` is an invalid PAN card number. z[A-Z]{5}\d{4}[A-Z]{1}r r r r r �ind_pan r r )�__doc__r �validators.utilsr �strr r r r r r �<module> s i18n/__pycache__/__init__.cpython-310.pyc 0000644 00000001000 15030212475 0013761 0 ustar 00 o �he � @ sT d Z ddlmZmZmZmZ ddlmZmZ ddl m Z m Z ddl m Z mZ dZdS )zi18n.� )�es_cif�es_doi�es_nie�es_nif)�fi_business_id�fi_ssn)� fr_department�fr_ssn)� ind_aadhar�ind_pan) r r r r r r r r r r N)�__doc__�esr r r r �fir r �frr r �indr r �__all__� r r �K/usr/local/CyberCP/lib/python3.10/site-packages/validators/i18n/__init__.py�<module> s i18n/__pycache__/es.cpython-310.pyc 0000644 00000012125 15030212475 0012643 0 ustar 00 o �h� � @ s� d Z ddlmZmZ ddlmZ dedeeef dee fdd�Zedefd d ��Zedefd d ��Z edefd d��Z edefdd��Z dS )zSpain.� )�Dict�Set)� validator�value�number_by_letter� special_casesc C sd | |v s t | �dkr dS | �� } d}|�| d | d �| dd� }|�� o1| d |t|�d kS )z&Validate if the doi is a NIF or a NIE.� F�TRWAGMYFPDXBNJZSQVHLCKEr � � � )�len�upper�get�isdigit�int)r r r �table�numbers� r �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/i18n/es.py�_nif_nie_validation s r c C s� | rt | �dkr dS | �� } d}| d }| dd� }| d }|�� s$dS dtdd � t|�D ��d d }|d v r?t|�|kS |d v rI|| |kS |d v rW|t|�|| hv S dS ) a� Validate a Spanish CIF. Each company in Spain prior to 2008 had a distinct CIF and has been discontinued. For more information see [wikipedia.org/cif][1]. The new replacement is to use NIF for absolutely everything. The issue is that there are "types" of NIFs now: company, person [citizen or resident] all distinguished by the first character of the DOI. For this reason we will continue to call CIFs NIFs, that are used for companies. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/C%C3%B3digo_de_identificaci%C3%B3n_fiscal [2]: https://generadordni.es/ Examples: >>> es_cif('B25162520') # Output: True >>> es_cif('B25162529') # Output: ValidationError(func=es_cif, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. r F� JABCDEFGHIr r r � c s sB � | ] \}}|d dkrt tttt|�d ���nt|�V qdS )� r N)�sum�mapr �str)�.0�index�charr r r � <genexpr>A s � ,� �zes_cif.<locals>.<genexpr>�ABEH�PSQW� CDFGJNRUV)r r r r � enumerater )r r � first_chr�doi_body�control�resr r r �es_cif s. ���� r) c C s dddd�}h d�}t | ||�S )a Validate a Spanish NIF. Each entity, be it person or company in Spain has a distinct NIF. Since we've designated CIF to be a company NIF, this NIF is only for person. For more information see [wikipedia.org/nif][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/N%C3%BAmero_de_identificaci%C3%B3n_fiscal [2]: https://generadordni.es/ Examples: >>> es_nif('26643189N') # Output: True >>> es_nif('26643189X') # Output: ValidationError(func=es_nif, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. �0)�L�M�K> � 00000000T� 00000001R� X0000000T�r )r r r r r r �es_nifP s r2 c C s. dddd�}| r| d |v rt | |dh�S dS )u� Validate a Spanish NIE. The NIE is a tax identification number in Spain, known in Spanish as the NIE, or more formally the Número de identidad de extranjero. For more information see [wikipedia.org/nie][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/N%C3%BAmero_de_identidad_de_extranjero [2]: https://generadordni.es/ Examples: >>> es_nie('X0095892M') # Output: True >>> es_nie('X0095892X') # Output: ValidationError(func=es_nie, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. r* �1�2)�X�Y�Zr r0 Fr1 )r r r r r �es_nieo s r8 c C s t | �p t| �p t| �S )a� Validate a Spanish DOI. A DOI in spain is all NIF / CIF / NIE / DNI -- a digital ID. For more information see [wikipedia.org/doi][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/Identificador_de_objeto_digital [2]: https://generadordni.es/ Examples: >>> es_doi('X0095892M') # Output: True >>> es_doi('X0095892X') # Output: ValidationError(func=es_doi, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. )r8 r2 r) )r r r r �es_doi� s r9 N) �__doc__�typingr r �validators.utilsr r r r) r2 r8 r9 r r r r �<module> s " 8 i18n/__pycache__/fr.cpython-310.pyc 0000644 00000006214 15030212475 0012645 0 ustar 00 o �hM � @ sj d Z ddlmZ ddlZddlZddlmZ edd� �Zedeje e f fdd ��Z ede fd d ��Z dS ) zFrance.� )� lru_cacheN)� validatorc C s t �dt j�S )z SSN Pattern.zW^([1,2])\s(\d{2})\s(0[1-9]|1[0-2])\s(\d{2,3}|2[A,B])\s(\d{2,3})\s(\d{3})(?:\s(\d{2}))?$)�re�compile�VERBOSE� r r �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/i18n/fr.py� _ssn_pattern s �r �valuec C s� | sdS t | t�r | dv rdS zt| �} W n ty Y dS w d| ko)dkn pCd| ko5dkn pCd| koAd kS S ) a) Validate a french department number. Examples: >>> fr_department(20) # can be an integer # Output: True >>> fr_department("20") # Output: True >>> fr_department("971") # Guadeloupe # Output: True >>> fr_department("00") # Output: ValidationError(func=fr_department, args=...) >>> fr_department('2A') # Corsica # Output: True >>> fr_department('2B') # Output: True >>> fr_department('2C') # Output: ValidationError(func=fr_department, args=...) Args: value: French department number to validate. Returns: (Literal[True]): If `value` is a valid french department number. (ValidationError): If `value` is an invalid french department number. F��2A�2BT� � � �_ i� i� )� isinstance�str�int� ValueError)r r r r � fr_department s �Hr c C s� | sdS t �t� | �}|sdS t|�� �}|d }|d }|dkr't|�s'dS |du r-dS t|�t|d �kr9dS |dv rG|d krCd nd |d< td �|dd� ��}t|�d |d kS )a� Validate a french Social Security Number. Each french citizen has a distinct Social Security Number. For more information see [French Social Security Number][1] (sadly unavailable in english). [1]: https://fr.wikipedia.org/wiki/Num%C3%A9ro_de_s%C3%A9curit%C3%A9_sociale_en_France Examples: >>> fr_ssn('1 84 12 76 451 089 46') # Output: True >>> fr_ssn('1 84 12 76 451 089') # control key is optional # Output: True >>> fr_ssn('3 84 12 76 451 089 46') # wrong gender number # Output: ValidationError(func=fr_ssn, args=...) >>> fr_ssn('1 84 12 76 451 089 47') # wrong control key # Output: ValidationError(func=fr_ssn, args=...) Args: value: French Social Security Number string to validate. Returns: (Literal[True]): If `value` is a valid french Social Security Number. (ValidationError): If `value` is an invalid french Social Security Number. F���� �99NT� r r �19�18� �a ) r �matchr �list�groupsr �lenr �join)r �matchedr! � control_key� department�digitsr r r �fr_ssnC s$ r( ) �__doc__� functoolsr r �typing�validators.utilsr r �Unionr r r r( r r r r �<module> s ' i18n/__pycache__/fi.cpython-310.pyc 0000644 00000006320 15030212475 0012632 0 ustar 00 o �h� � @ st d Z ddlmZ ddlZddlmZ edd� �Zedefdd ��Zed efd d ��Z ed d�d ede fdd��Z dS )zFinland.� )� lru_cacheN)� validatorc C s t �d�S )zBusiness ID Pattern.z^[0-9]{7}-[0-9]$)�re�compile� r r �E/usr/local/CyberCP/lib/python3.10/site-packages/validators/i18n/fi.py�_business_id_pattern s r �ssn_check_marksc C s t �dj| d�t j�S )z SSN Pattern.z�^ (?P<date>(0[1-9]|[1-2]\d|3[01]) (0[1-9]|1[012]) (\d{{2}})) [ABCDEFYXWVU+-] (?P<serial>(\d{{3}})) (?P<checksum>[{check_marks}])$)� check_marks)r r �format�VERBOSE)r r r r � _ssn_pattern s � �r �valuec C s� | sdS t �t� | �s dS g d�}tt| dd� �}t| d �}tdd� t||�D ��d }d| |kp?|| ko=d kS S ) a� Validate a Finnish Business ID. Each company in Finland has a distinct business id. For more information see [Finnish Trade Register][1] [1]: http://en.wikipedia.org/wiki/Finnish_Trade_Register Examples: >>> fi_business_id('0112038-9') # Fast Monkeys Ltd # Output: True >>> fi_business_id('1234567-8') # Bogus ID # Output: ValidationError(func=fi_business_id, ...) Args: value: Business ID string to be validated. Returns: (Literal[True]): If `value` is a valid finnish business id. (ValidationError): If `value` is an invalid finnish business id. F)� � � � � � � Nr r c s s � | ] \}}|| V qd S )Nr )�.0�f�nr r r � <genexpr>@ s � z!fi_business_id.<locals>.<genexpr>� r )r �matchr �map�int�sum�zip)r �factors�numbers�checksum�modulor r r �fi_business_id" s $r$ T)�allow_temporal_ssnr% c C s| | sdS d}t �t|�| � }sdS |�� }t|d |d �}t|d �dko=|p1t|d �dko=||t|� |d kS )a Validate a Finnish Social Security Number. This validator is based on [django-localflavor-fi][1]. [1]: https://github.com/django/django-localflavor-fi/ Examples: >>> fi_ssn('010101-0101') # Output: True >>> fi_ssn('101010-0102') # Output: ValidationError(func=fi_ssn, args=...) Args: value: Social Security Number to be validated. allow_temporal_ssn: Whether to accept temporal SSN numbers. Temporal SSN numbers are the ones where the serial is in the range [900-999]. By default temporal SSN numbers are valid. Returns: (Literal[True]): If `value` is a valid finnish SSN. (ValidationError): If `value` is an invalid finnish SSN. F� 0123456789ABCDEFHJKLMNPRSTUVWXY�date�serialr i� r" )r r r � groupdictr �len)r r% r �result�gdr" r r r �fi_ssnD s ��r- ) �__doc__� functoolsr r �validators.utilsr r �strr r$ �boolr- r r r r �<module> s ! i18n/es.py 0000644 00000012275 15030212475 0006312 0 ustar 00 """Spain.""" # standard from typing import Dict, Set # local from validators.utils import validator def _nif_nie_validation(value: str, number_by_letter: Dict[str, str], special_cases: Set[str]): """Validate if the doi is a NIF or a NIE.""" if value in special_cases or len(value) != 9: return False value = value.upper() table = "TRWAGMYFPDXBNJZSQVHLCKE" # If it is not a DNI, convert the first # letter to the corresponding digit numbers = number_by_letter.get(value[0], value[0]) + value[1:8] # doi[8] is control return numbers.isdigit() and value[8] == table[int(numbers) % 23] @validator def es_cif(value: str, /): """Validate a Spanish CIF. Each company in Spain prior to 2008 had a distinct CIF and has been discontinued. For more information see [wikipedia.org/cif][1]. The new replacement is to use NIF for absolutely everything. The issue is that there are "types" of NIFs now: company, person [citizen or resident] all distinguished by the first character of the DOI. For this reason we will continue to call CIFs NIFs, that are used for companies. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/C%C3%B3digo_de_identificaci%C3%B3n_fiscal [2]: https://generadordni.es/ Examples: >>> es_cif('B25162520') # Output: True >>> es_cif('B25162529') # Output: ValidationError(func=es_cif, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. """ if not value or len(value) != 9: return False value = value.upper() table = "JABCDEFGHI" first_chr = value[0] doi_body = value[1:8] control = value[8] if not doi_body.isdigit(): return False res = ( 10 - sum( # Multiply each positionally even doi # digit by 2 and sum it all together sum(map(int, str(int(char) * 2))) if index % 2 == 0 else int(char) for index, char in enumerate(doi_body) ) % 10 ) % 10 if first_chr in "ABEH": # Number type return str(res) == control if first_chr in "PSQW": # Letter type return table[res] == control return control in {str(res), table[res]} if first_chr in "CDFGJNRUV" else False @validator def es_nif(value: str, /): """Validate a Spanish NIF. Each entity, be it person or company in Spain has a distinct NIF. Since we've designated CIF to be a company NIF, this NIF is only for person. For more information see [wikipedia.org/nif][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/N%C3%BAmero_de_identificaci%C3%B3n_fiscal [2]: https://generadordni.es/ Examples: >>> es_nif('26643189N') # Output: True >>> es_nif('26643189X') # Output: ValidationError(func=es_nif, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. """ number_by_letter = {"L": "0", "M": "0", "K": "0"} special_cases = {"X0000000T", "00000000T", "00000001R"} return _nif_nie_validation(value, number_by_letter, special_cases) @validator def es_nie(value: str, /): """Validate a Spanish NIE. The NIE is a tax identification number in Spain, known in Spanish as the NIE, or more formally the Número de identidad de extranjero. For more information see [wikipedia.org/nie][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/N%C3%BAmero_de_identidad_de_extranjero [2]: https://generadordni.es/ Examples: >>> es_nie('X0095892M') # Output: True >>> es_nie('X0095892X') # Output: ValidationError(func=es_nie, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. """ number_by_letter = {"X": "0", "Y": "1", "Z": "2"} # NIE must must start with X Y or Z if value and value[0] in number_by_letter: return _nif_nie_validation(value, number_by_letter, {"X0000000T"}) return False @validator def es_doi(value: str, /): """Validate a Spanish DOI. A DOI in spain is all NIF / CIF / NIE / DNI -- a digital ID. For more information see [wikipedia.org/doi][1]. This validator is based on [generadordni.es][2]. [1]: https://es.wikipedia.org/wiki/Identificador_de_objeto_digital [2]: https://generadordni.es/ Examples: >>> es_doi('X0095892M') # Output: True >>> es_doi('X0095892X') # Output: ValidationError(func=es_doi, args=...) Args: value: DOI string which is to be validated. Returns: (Literal[True]): If `value` is a valid DOI string. (ValidationError): If `value` is an invalid DOI string. """ return es_nie(value) or es_nif(value) or es_cif(value) i18n/ind.py 0000644 00000002171 15030212475 0006447 0 ustar 00 """India.""" # standard import re # local from validators.utils import validator @validator def ind_aadhar(value: str): """Validate an indian aadhar card number. Examples: >>> ind_aadhar('3675 9834 6015') True >>> ind_aadhar('3675 ABVC 2133') ValidationFailure(func=aadhar, args={'value': '3675 ABVC 2133'}) Args: value: Aadhar card number string to validate. Returns: (Literal[True]): If `value` is a valid aadhar card number. (ValidationError): If `value` is an invalid aadhar card number. """ return re.match(r"^[2-9]{1}\d{3}\s\d{4}\s\d{4}$", value) @validator def ind_pan(value: str): """Validate a pan card number. Examples: >>> ind_pan('ABCDE9999K') True >>> ind_pan('ABC5d7896B') ValidationFailure(func=pan, args={'value': 'ABC5d7896B'}) Args: value: PAN card number string to validate. Returns: (Literal[True]): If `value` is a valid PAN card number. (ValidationError): If `value` is an invalid PAN card number. """ return re.match(r"[A-Z]{5}\d{4}[A-Z]{1}", value) i18n/__init__.py 0000644 00000000545 15030212475 0007437 0 ustar 00 """i18n.""" # local from .es import es_cif, es_doi, es_nie, es_nif from .fi import fi_business_id, fi_ssn from .fr import fr_department, fr_ssn from .ind import ind_aadhar, ind_pan __all__ = ( "fi_business_id", "fi_ssn", "es_cif", "es_doi", "es_nie", "es_nif", "fr_department", "fr_ssn", "ind_aadhar", "ind_pan", ) i18n/fi.py 0000644 00000005631 15030212475 0006277 0 ustar 00 """Finland.""" # standard from functools import lru_cache import re # local from validators.utils import validator @lru_cache def _business_id_pattern(): """Business ID Pattern.""" return re.compile(r"^[0-9]{7}-[0-9]$") @lru_cache def _ssn_pattern(ssn_check_marks: str): """SSN Pattern.""" return re.compile( r"""^ (?P<date>(0[1-9]|[1-2]\d|3[01]) (0[1-9]|1[012]) (\d{{2}})) [ABCDEFYXWVU+-] (?P<serial>(\d{{3}})) (?P<checksum>[{check_marks}])$""".format( check_marks=ssn_check_marks ), re.VERBOSE, ) @validator def fi_business_id(value: str, /): """Validate a Finnish Business ID. Each company in Finland has a distinct business id. For more information see [Finnish Trade Register][1] [1]: http://en.wikipedia.org/wiki/Finnish_Trade_Register Examples: >>> fi_business_id('0112038-9') # Fast Monkeys Ltd # Output: True >>> fi_business_id('1234567-8') # Bogus ID # Output: ValidationError(func=fi_business_id, ...) Args: value: Business ID string to be validated. Returns: (Literal[True]): If `value` is a valid finnish business id. (ValidationError): If `value` is an invalid finnish business id. """ if not value: return False if not re.match(_business_id_pattern(), value): return False factors = [7, 9, 10, 5, 8, 4, 2] numbers = map(int, value[:7]) checksum = int(value[8]) modulo = sum(f * n for f, n in zip(factors, numbers)) % 11 return (11 - modulo == checksum) or (modulo == checksum == 0) @validator def fi_ssn(value: str, /, *, allow_temporal_ssn: bool = True): """Validate a Finnish Social Security Number. This validator is based on [django-localflavor-fi][1]. [1]: https://github.com/django/django-localflavor-fi/ Examples: >>> fi_ssn('010101-0101') # Output: True >>> fi_ssn('101010-0102') # Output: ValidationError(func=fi_ssn, args=...) Args: value: Social Security Number to be validated. allow_temporal_ssn: Whether to accept temporal SSN numbers. Temporal SSN numbers are the ones where the serial is in the range [900-999]. By default temporal SSN numbers are valid. Returns: (Literal[True]): If `value` is a valid finnish SSN. (ValidationError): If `value` is an invalid finnish SSN. """ if not value: return False ssn_check_marks = "0123456789ABCDEFHJKLMNPRSTUVWXY" if not (result := re.match(_ssn_pattern(ssn_check_marks), value)): return False gd = result.groupdict() checksum = int(gd["date"] + gd["serial"]) return ( int(gd["serial"]) >= 2 and (allow_temporal_ssn or int(gd["serial"]) <= 899) and ssn_check_marks[checksum % len(ssn_check_marks)] == gd["checksum"] ) email.py 0000644 00000005344 15030212475 0006212 0 ustar 00 """eMail.""" # standard import re # local from .hostname import hostname from .utils import validator @validator def email( value: str, /, *, ipv6_address: bool = False, ipv4_address: bool = False, simple_host: bool = False, rfc_1034: bool = False, rfc_2782: bool = False, ): """Validate an email address. This was inspired from [Django's email validator][1]. Also ref: [RFC 1034][2], [RFC 5321][3] and [RFC 5322][4]. [1]: https://github.com/django/django/blob/main/django/core/validators.py#L174 [2]: https://www.rfc-editor.org/rfc/rfc1034 [3]: https://www.rfc-editor.org/rfc/rfc5321 [4]: https://www.rfc-editor.org/rfc/rfc5322 Examples: >>> email('someone@example.com') # Output: True >>> email('bogus@@') # Output: ValidationError(email=email, args={'value': 'bogus@@'}) Args: value: eMail string to validate. ipv6_address: When the domain part is an IPv6 address. ipv4_address: When the domain part is an IPv4 address. simple_host: When the domain part is a simple hostname. rfc_1034: Allow trailing dot in domain name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain name is of type service record. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid eMail. (ValidationError): If `value` is an invalid eMail. """ if not value or value.count("@") != 1: return False username_part, domain_part = value.rsplit("@", 1) if len(username_part) > 64 or len(domain_part) > 253: # ref: RFC 1034 and 5231 return False if ipv6_address or ipv4_address: if domain_part.startswith("[") and domain_part.endswith("]"): # ref: RFC 5321 domain_part = domain_part.lstrip("[").rstrip("]") else: return False return ( bool( hostname( domain_part, skip_ipv6_addr=not ipv6_address, skip_ipv4_addr=not ipv4_address, may_have_port=False, maybe_simple=simple_host, rfc_1034=rfc_1034, rfc_2782=rfc_2782, ) ) if re.match( # extended latin r"(^[\u0100-\u017F\u0180-\u024F]" # dot-atom + r"|[-!#$%&'*+/=?^_`{}|~0-9a-z]+(\.[-!#$%&'*+/=?^_`{}|~0-9a-z]+)*$" # quoted-string + r'|^"([\001-\010\013\014\016-\037!#-\[\]-\177]|\\[\011.])*"$)', username_part, re.IGNORECASE, ) else False ) cron.py 0000644 00000004351 15030212475 0006061 0 ustar 00 """Cron.""" # local from .utils import validator def _validate_cron_component(component: str, min_val: int, max_val: int): if component == "*": return True if component.isdecimal(): return min_val <= int(component) <= max_val if "/" in component: parts = component.split("/") if len(parts) != 2 or not parts[1].isdecimal() or int(parts[1]) < 1: return False if parts[0] == "*": return True return parts[0].isdecimal() and min_val <= int(parts[0]) <= max_val if "-" in component: parts = component.split("-") if len(parts) != 2 or not parts[0].isdecimal() or not parts[1].isdecimal(): return False start, end = int(parts[0]), int(parts[1]) return min_val <= start <= max_val and min_val <= end <= max_val and start <= end if "," in component: for item in component.split(","): if not _validate_cron_component(item, min_val, max_val): return False return True # return all( # _validate_cron_component(item, min_val, max_val) for item in component.split(",") # ) # throws type error. why? return False @validator def cron(value: str, /): """Return whether or not given value is a valid cron string. Examples: >>> cron('*/5 * * * *') # Output: True >>> cron('30-20 * * * *') # Output: ValidationError(func=cron, ...) Args: value: Cron string to validate. Returns: (Literal[True]): If `value` is a valid cron string. (ValidationError): If `value` is an invalid cron string. """ if not value: return False try: minutes, hours, days, months, weekdays = value.strip().split() except ValueError as err: raise ValueError("Badly formatted cron string") from err if not _validate_cron_component(minutes, 0, 59): return False if not _validate_cron_component(hours, 0, 23): return False if not _validate_cron_component(days, 1, 31): return False if not _validate_cron_component(months, 1, 12): return False if not _validate_cron_component(weekdays, 0, 6): return False return True card.py 0000644 00000013206 15030212475 0006030 0 ustar 00 """Card.""" # standard import re # local from .utils import validator @validator def card_number(value: str, /): """Return whether or not given value is a valid generic card number. This validator is based on [Luhn's algorithm][1]. [1]: https://github.com/mmcloughlin/luhn Examples: >>> card_number('4242424242424242') # Output: True >>> card_number('4242424242424241') # Output: ValidationError(func=card_number, args={'value': '4242424242424241'}) Args: value: Generic card number string to validate Returns: (Literal[True]): If `value` is a valid generic card number. (ValidationError): If `value` is an invalid generic card number. """ if not value: return False try: digits = list(map(int, value)) odd_sum = sum(digits[-1::-2]) even_sum = sum(sum(divmod(2 * d, 10)) for d in digits[-2::-2]) return (odd_sum + even_sum) % 10 == 0 except ValueError: return False @validator def visa(value: str, /): """Return whether or not given value is a valid Visa card number. Examples: >>> visa('4242424242424242') # Output: True >>> visa('2223003122003222') # Output: ValidationError(func=visa, args={'value': '2223003122003222'}) Args: value: Visa card number string to validate Returns: (Literal[True]): If `value` is a valid Visa card number. (ValidationError): If `value` is an invalid Visa card number. """ pattern = re.compile(r"^4") return card_number(value) and len(value) == 16 and pattern.match(value) @validator def mastercard(value: str, /): """Return whether or not given value is a valid Mastercard card number. Examples: >>> mastercard('5555555555554444') # Output: True >>> mastercard('4242424242424242') # Output: ValidationError(func=mastercard, args={'value': '4242424242424242'}) Args: value: Mastercard card number string to validate Returns: (Literal[True]): If `value` is a valid Mastercard card number. (ValidationError): If `value` is an invalid Mastercard card number. """ pattern = re.compile(r"^(51|52|53|54|55|22|23|24|25|26|27)") return card_number(value) and len(value) == 16 and pattern.match(value) @validator def amex(value: str, /): """Return whether or not given value is a valid American Express card number. Examples: >>> amex('378282246310005') # Output: True >>> amex('4242424242424242') # Output: ValidationError(func=amex, args={'value': '4242424242424242'}) Args: value: American Express card number string to validate Returns: (Literal[True]): If `value` is a valid American Express card number. (ValidationError): If `value` is an invalid American Express card number. """ pattern = re.compile(r"^(34|37)") return card_number(value) and len(value) == 15 and pattern.match(value) @validator def unionpay(value: str, /): """Return whether or not given value is a valid UnionPay card number. Examples: >>> unionpay('6200000000000005') # Output: True >>> unionpay('4242424242424242') # Output: ValidationError(func=unionpay, args={'value': '4242424242424242'}) Args: value: UnionPay card number string to validate Returns: (Literal[True]): If `value` is a valid UnionPay card number. (ValidationError): If `value` is an invalid UnionPay card number. """ pattern = re.compile(r"^62") return card_number(value) and len(value) == 16 and pattern.match(value) @validator def diners(value: str, /): """Return whether or not given value is a valid Diners Club card number. Examples: >>> diners('3056930009020004') # Output: True >>> diners('4242424242424242') # Output: ValidationError(func=diners, args={'value': '4242424242424242'}) Args: value: Diners Club card number string to validate Returns: (Literal[True]): If `value` is a valid Diners Club card number. (ValidationError): If `value` is an invalid Diners Club card number. """ pattern = re.compile(r"^(30|36|38|39)") return card_number(value) and len(value) in {14, 16} and pattern.match(value) @validator def jcb(value: str, /): """Return whether or not given value is a valid JCB card number. Examples: >>> jcb('3566002020360505') # Output: True >>> jcb('4242424242424242') # Output: ValidationError(func=jcb, args={'value': '4242424242424242'}) Args: value: JCB card number string to validate Returns: (Literal[True]): If `value` is a valid JCB card number. (ValidationError): If `value` is an invalid JCB card number. """ pattern = re.compile(r"^35") return card_number(value) and len(value) == 16 and pattern.match(value) @validator def discover(value: str, /): """Return whether or not given value is a valid Discover card number. Examples: >>> discover('6011111111111117') # Output: True >>> discover('4242424242424242') # Output: ValidationError(func=discover, args={'value': '4242424242424242'}) Args: value: Discover card number string to validate Returns: (Literal[True]): If `value` is a valid Discover card number. (ValidationError): If `value` is an invalid Discover card number. """ pattern = re.compile(r"^(60|64|65)") return card_number(value) and len(value) == 16 and pattern.match(value) domain.py 0000644 00000004734 15030212475 0006374 0 ustar 00 """Domain.""" # standard from pathlib import Path import re # local from .utils import validator def _iana_tld(): """Load IANA TLDs as a Generator.""" # source: https://data.iana.org/TLD/tlds-alpha-by-domain.txt with Path(__file__).parent.joinpath("_tld.txt").open() as tld_f: _ = next(tld_f) # ignore the first line for line in tld_f: yield line.strip() @validator def domain( value: str, /, *, consider_tld: bool = False, rfc_1034: bool = False, rfc_2782: bool = False ): """Return whether or not given value is a valid domain. Examples: >>> domain('example.com') # Output: True >>> domain('example.com/') # Output: ValidationError(func=domain, ...) >>> # Supports IDN domains as well:: >>> domain('xn----gtbspbbmkef.xn--p1ai') # Output: True Args: value: Domain string to validate. consider_tld: Restrict domain to TLDs allowed by IANA. rfc_1034: Allows optional trailing dot in the domain name. Ref: [RFC 1034](https://www.rfc-editor.org/rfc/rfc1034). rfc_2782: Domain name is of type service record. Allows optional underscores in the domain name. Ref: [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782). Returns: (Literal[True]): If `value` is a valid domain name. (ValidationError): If `value` is an invalid domain name. Raises: (UnicodeError): If `value` cannot be encoded into `idna` or decoded into `utf-8`. """ if not value: return False if consider_tld and value.rstrip(".").rsplit(".", 1)[-1].upper() not in _iana_tld(): return False try: service_record = r"_" if rfc_2782 else "" trailing_dot = r"\.?$" if rfc_1034 else r"$" return not re.search(r"\s|__+", value) and re.match( # First character of the domain rf"^(?:[a-z0-9{service_record}]" # Sub-domain + rf"(?:[a-z0-9-{service_record}]{{0,61}}" # Hostname + rf"[a-z0-9{service_record}])?\.)" # First 61 characters of the gTLD + r"+[a-z0-9][a-z0-9-_]{0,61}" # Last character of the gTLD + rf"[a-z]{trailing_dot}", value.encode("idna").decode("utf-8"), re.IGNORECASE, ) except UnicodeError as err: raise UnicodeError(f"Unable to encode/decode {value}") from err crypto_addresses/eth_address.py 0000644 00000003214 15030212475 0012757 0 ustar 00 """ETH Address.""" # standard import re # local from validators.utils import validator _keccak_flag = True try: # external from eth_hash.auto import keccak except ImportError: _keccak_flag = False def _validate_eth_checksum_address(addr: str): """Validate ETH type checksum address.""" addr = addr.replace("0x", "") addr_hash = keccak.new(addr.lower().encode("ascii")).digest().hex() # type: ignore if len(addr) != 40: return False for i in range(0, 40): if (int(addr_hash[i], 16) > 7 and addr[i].upper() != addr[i]) or ( int(addr_hash[i], 16) <= 7 and addr[i].lower() != addr[i] ): return False return True @validator def eth_address(value: str, /): """Return whether or not given value is a valid ethereum address. Full validation is implemented for ERC20 addresses. Examples: >>> eth_address('0x9cc14ba4f9f68ca159ea4ebf2c292a808aaeb598') # Output: True >>> eth_address('0x8Ba1f109551bD432803012645Ac136ddd64DBa72') # Output: ValidationError(func=eth_address, args=...) Args: value: Ethereum address string to validate. Returns: (Literal[True]): If `value` is a valid ethereum address. (ValidationError): If `value` is an invalid ethereum address. """ if not _keccak_flag: raise ImportError( "Do `pip install validators[crypto-eth-addresses]` to perform `eth_address` validation." ) if not value: return False return re.compile(r"^0x[0-9a-f]{40}$|^0x[0-9A-F]{40}$").match( value ) or _validate_eth_checksum_address(value) crypto_addresses/bsc_address.py 0000644 00000001533 15030212475 0012750 0 ustar 00 """BSC Address.""" # standard import re # local from validators.utils import validator @validator def bsc_address(value: str, /): """Return whether or not given value is a valid binance smart chain address. Full validation is implemented for BSC addresses. Examples: >>> bsc_address('0x4e5acf9684652BEa56F2f01b7101a225Ee33d23f') # Output: True >>> bsc_address('0x4g5acf9684652BEa56F2f01b7101a225Eh33d23z') # Output: ValidationError(func=bsc_address, args=...) Args: value: BSC address string to validate. Returns: (Literal[True]): If `value` is a valid bsc address. (ValidationError): If `value` is an invalid bsc address. """ if not value: return False if not re.fullmatch(r"0x[a-fA-F0-9]{40}", value): return False return True crypto_addresses/__pycache__/eth_address.cpython-310.pyc 0000644 00000003404 15030212475 0017317 0 ustar 00 o �h� � @ sh d Z ddlZddlmZ dZzddlmZ W n ey! dZY nw defdd �Z ed efd d ��Z dS ) z ETH Address.� N)� validatorT)�keccakF�addrc C s� | � dd�} t�| �� �d���� �� }t| �dkr dS tdd�D ]+}t || d�dkr6| | � � | | ksIt || d�dkrL| | �� | | krL dS q!d S ) z#Validate ETH type checksum address.�0x� �ascii�( Fr � � T) �replacer �new�lower�encode�digest�hex�len�range�int�upper)r � addr_hash�i� r �Z/usr/local/CyberCP/lib/python3.10/site-packages/validators/crypto_addresses/eth_address.py� _validate_eth_checksum_address s &&�r �valuec C s, t std��| s dS t�d��| �pt| �S )aL Return whether or not given value is a valid ethereum address. Full validation is implemented for ERC20 addresses. Examples: >>> eth_address('0x9cc14ba4f9f68ca159ea4ebf2c292a808aaeb598') # Output: True >>> eth_address('0x8Ba1f109551bD432803012645Ac136ddd64DBa72') # Output: ValidationError(func=eth_address, args=...) Args: value: Ethereum address string to validate. Returns: (Literal[True]): If `value` is a valid ethereum address. (ValidationError): If `value` is an invalid ethereum address. zVDo `pip install validators[crypto-eth-addresses]` to perform `eth_address` validation.Fz!^0x[0-9a-f]{40}$|^0x[0-9A-F]{40}$)� _keccak_flag� ImportError�re�compile�matchr )r r r r � eth_address! s � ��r ) �__doc__r �validators.utilsr r � eth_hash.autor r �strr r r r r r �<module> s � crypto_addresses/__pycache__/btc_address.cpython-310.pyc 0000644 00000004032 15030212475 0017305 0 ustar 00 o �h� � @ sV d Z ddlmZ ddlZddlmZ defdd�Zdefdd �Zed efd d ��Z dS ) z BTC Address.� )�sha256N)� validator�addrc s( d� t � fdd�t| ddd� �D ��S )zDecode base58.�:123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyzc 3 s& � | ]\}}d | � � |� V qdS )�: N)�index)�.0�enm�idx��alphabet� �Z/usr/local/CyberCP/lib/python3.10/site-packages/validators/crypto_addresses/btc_address.py� <genexpr> s �$ z!_decode_base58.<locals>.<genexpr>N���)�sum� enumerate)r r r r �_decode_base58 s $r c C s` t | �tdd�vr dS t| ��dd�}|dd� |dd� }}|tt|��� ��� dd� kS )z%Validate P2PKH and P2SH type address.� �# F�bigN���� )�len�ranger �to_bytesr �digest)r � decoded_bytes�header�checksumr r r �_validate_old_btc_address s r �valuec C s0 | sdS | dd� dv rt �d��| �S t| �S )a� Return whether or not given value is a valid bitcoin address. Full validation is implemented for P2PKH and P2SH addresses. For segwit addresses a regexp is used to provide a reasonable estimate on whether the address is valid. Examples: >>> btc_address('3Cwgr2g7vsi1bXDUkpEnVoRLA9w4FZfC69') # Output: True >>> btc_address('1BvBMsEYstWetqTFn5Au4m4GFg7xJaNVN2') # Output: ValidationError(func=btc_address, args=...) Args: value: Bitcoin address string to validate. Returns: (Literal[True]): If `value` is a valid bitcoin address. (ValidationError): If `value` is an invalid bitcoin address. FN� )�bc�tbz%^(bc|tc)[0-3][02-9ac-hj-np-z]{14,74}$)�re�compile�matchr )r! r r r � btc_address s ���r( ) �__doc__�hashlibr r% �validators.utilsr �strr r r( r r r r �<module> s crypto_addresses/__pycache__/__init__.cpython-310.pyc 0000644 00000000603 15030212475 0016567 0 ustar 00 o �h� � @ s< d Z ddlmZ ddlmZ ddlmZ ddlmZ dZdS )zCrypto addresses.� )� bsc_address)� btc_address)� eth_address)� trx_address)r r r r N)�__doc__r r r r �__all__� r r �W/usr/local/CyberCP/lib/python3.10/site-packages/validators/crypto_addresses/__init__.py�<module> s crypto_addresses/__pycache__/trx_address.cpython-310.pyc 0000644 00000003510 15030212475 0017352 0 ustar 00 o �hD � @ sZ d Z ddlZddlZddlmZ dedefdd�Zdedefdd �Z ed efd d ��Z dS ) z TRX Address.� N)� validator�addr�returnc C s2 d}d}| D ] }|d |� |� }q|jddd�S )z Decode a base58 encoded address.�:123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyzr �: � �big)� byteorder)�index�to_bytes)r �alphabet�num�char� r �Z/usr/local/CyberCP/lib/python3.10/site-packages/validators/crypto_addresses/trx_address.py�_base58_decode s r c C s� t | �dkrdS zt| �}W n ty Y dS w t |�dks%|d dkr'dS t�t�|dd� ��� ��� dd� }|dd� |kS ) z#Validate TRX type checksum address.�" Fr r �A N���� )�lenr � ValueError�hashlib�sha256�digest)r �address� check_sumr r r � _validate_trx_checksum_address s �(r �valuec C s | sdS t �d��| �ot| �S )a0 Return whether or not given value is a valid tron address. Full validation is implemented for TRC20 tron addresses. Examples: >>> trx_address('TLjfbTbpZYDQ4EoA4N5CLNgGjfbF8ZWz38') # Output: True >>> trx_address('TR2G7Rm4vFqF8EpY4U5xdLdQ7XgJ2U8Vd') # Output: ValidationError(func=trx_address, args=...) Args: value: Tron address string to validate. Returns: (Literal[True]): If `value` is a valid tron address. (ValidationError): If `value` is an invalid tron address. Fz ^[T][a-km-zA-HJ-NP-Z1-9]{33}$)�re�compile�matchr )r r r r � trx_address% s ��r" ) �__doc__r r �validators.utilsr �str�bytesr �boolr r" r r r r �<module> s crypto_addresses/__pycache__/bsc_address.cpython-310.pyc 0000644 00000002044 15030212475 0017305 0 ustar 00 o �h[ � @ s. d Z ddlZddlmZ edefdd��ZdS )z BSC Address.� N)� validator�valuec C s | sdS t �d| �s dS dS )aF Return whether or not given value is a valid binance smart chain address. Full validation is implemented for BSC addresses. Examples: >>> bsc_address('0x4e5acf9684652BEa56F2f01b7101a225Ee33d23f') # Output: True >>> bsc_address('0x4g5acf9684652BEa56F2f01b7101a225Eh33d23z') # Output: ValidationError(func=bsc_address, args=...) Args: value: BSC address string to validate. Returns: (Literal[True]): If `value` is a valid bsc address. (ValidationError): If `value` is an invalid bsc address. Fz0x[a-fA-F0-9]{40}T)�re� fullmatch)r � r �Z/usr/local/CyberCP/lib/python3.10/site-packages/validators/crypto_addresses/bsc_address.py� bsc_address s r )�__doc__r �validators.utilsr �strr r r r r �<module> s crypto_addresses/btc_address.py 0000644 00000003201 15030212475 0012743 0 ustar 00 """BTC Address.""" # standard from hashlib import sha256 import re # local from validators.utils import validator def _decode_base58(addr: str): """Decode base58.""" alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" return sum((58**enm) * alphabet.index(idx) for enm, idx in enumerate(addr[::-1])) def _validate_old_btc_address(addr: str): """Validate P2PKH and P2SH type address.""" if len(addr) not in range(25, 35): return False decoded_bytes = _decode_base58(addr).to_bytes(25, "big") header, checksum = decoded_bytes[:-4], decoded_bytes[-4:] return checksum == sha256(sha256(header).digest()).digest()[:4] @validator def btc_address(value: str, /): """Return whether or not given value is a valid bitcoin address. Full validation is implemented for P2PKH and P2SH addresses. For segwit addresses a regexp is used to provide a reasonable estimate on whether the address is valid. Examples: >>> btc_address('3Cwgr2g7vsi1bXDUkpEnVoRLA9w4FZfC69') # Output: True >>> btc_address('1BvBMsEYstWetqTFn5Au4m4GFg7xJaNVN2') # Output: ValidationError(func=btc_address, args=...) Args: value: Bitcoin address string to validate. Returns: (Literal[True]): If `value` is a valid bitcoin address. (ValidationError): If `value` is an invalid bitcoin address. """ if not value: return False return ( # segwit pattern re.compile(r"^(bc|tc)[0-3][02-9ac-hj-np-z]{14,74}$").match(value) if value[:2] in ("bc", "tb") else _validate_old_btc_address(value) ) crypto_addresses/trx_address.py 0000644 00000003104 15030212475 0013012 0 ustar 00 """TRX Address.""" # standard import hashlib import re # local from validators.utils import validator def _base58_decode(addr: str) -> bytes: """Decode a base58 encoded address.""" alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" num = 0 for char in addr: num = num * 58 + alphabet.index(char) return num.to_bytes(25, byteorder="big") def _validate_trx_checksum_address(addr: str) -> bool: """Validate TRX type checksum address.""" if len(addr) != 34: return False try: address = _base58_decode(addr) except ValueError: return False if len(address) != 25 or address[0] != 0x41: return False check_sum = hashlib.sha256(hashlib.sha256(address[:-4]).digest()).digest()[:4] return address[-4:] == check_sum @validator def trx_address(value: str, /): """Return whether or not given value is a valid tron address. Full validation is implemented for TRC20 tron addresses. Examples: >>> trx_address('TLjfbTbpZYDQ4EoA4N5CLNgGjfbF8ZWz38') # Output: True >>> trx_address('TR2G7Rm4vFqF8EpY4U5xdLdQ7XgJ2U8Vd') # Output: ValidationError(func=trx_address, args=...) Args: value: Tron address string to validate. Returns: (Literal[True]): If `value` is a valid tron address. (ValidationError): If `value` is an invalid tron address. """ if not value: return False return re.compile(r"^[T][a-km-zA-HJ-NP-Z1-9]{33}$").match( value ) and _validate_trx_checksum_address(value) crypto_addresses/__init__.py 0000644 00000000375 15030212475 0012236 0 ustar 00 """Crypto addresses.""" # local from .bsc_address import bsc_address from .btc_address import btc_address from .eth_address import eth_address from .trx_address import trx_address __all__ = ("bsc_address", "btc_address", "eth_address", "trx_address") length.py 0000644 00000002715 15030212475 0006403 0 ustar 00 """Length.""" # standard from typing import Union # local from .between import between from .utils import validator @validator def length(value: str, /, *, min_val: Union[int, None] = None, max_val: Union[int, None] = None): """Return whether or not the length of given string is within a specified range. Examples: >>> length('something', min_val=2) # Output: True >>> length('something', min_val=9, max_val=9) # Output: True >>> length('something', max_val=5) # Output: ValidationError(func=length, ...) Args: value: The string to validate. min_val: The minimum required length of the string. If not provided, minimum length will not be checked. max_val: The maximum length of the string. If not provided, maximum length will not be checked. Returns: (Literal[True]): If `len(value)` is in between the given conditions. (ValidationError): If `len(value)` is not in between the given conditions. Raises: (ValueError): If either `min_val` or `max_val` is negative. """ if min_val is not None and min_val < 0: raise ValueError("Length cannot be negative. `min_val` is less than zero.") if max_val is not None and max_val < 0: raise ValueError("Length cannot be negative. `max_val` is less than zero.") return bool(between(len(value), min_val=min_val, max_val=max_val)) encoding.py 0000644 00000004736 15030212475 0006715 0 ustar 00 """Encoding.""" # standard import re # local from .utils import validator @validator def base16(value: str, /): """Return whether or not given value is a valid base16 encoding. Examples: >>> base16('a3f4b2') # Output: True >>> base16('a3f4Z1') # Output: ValidationError(func=base16, args={'value': 'a3f4Z1'}) Args: value: base16 string to validate. Returns: (Literal[True]): If `value` is a valid base16 encoding. (ValidationError): If `value` is an invalid base16 encoding. """ return re.match(r"^[0-9A-Fa-f]+$", value) if value else False @validator def base32(value: str, /): """Return whether or not given value is a valid base32 encoding. Examples: >>> base32('MFZWIZLTOQ======') # Output: True >>> base32('MfZW3zLT9Q======') # Output: ValidationError(func=base32, args={'value': 'MfZW3zLT9Q======'}) Args: value: base32 string to validate. Returns: (Literal[True]): If `value` is a valid base32 encoding. (ValidationError): If `value` is an invalid base32 encoding. """ return re.match(r"^[A-Z2-7]+=*$", value) if value else False @validator def base58(value: str, /): """Return whether or not given value is a valid base58 encoding. Examples: >>> base58('14pq6y9H2DLGahPsM4s7ugsNSD2uxpHsJx') # Output: True >>> base58('cUSECm5YzcXJwP') # Output: ValidationError(func=base58, args={'value': 'cUSECm5YzcXJwP'}) Args: value: base58 string to validate. Returns: (Literal[True]): If `value` is a valid base58 encoding. (ValidationError): If `value` is an invalid base58 encoding. """ return re.match(r"^[1-9A-HJ-NP-Za-km-z]+$", value) if value else False @validator def base64(value: str, /): """Return whether or not given value is a valid base64 encoding. Examples: >>> base64('Y2hhcmFjdGVyIHNldA==') # Output: True >>> base64('cUSECm5YzcXJwP') # Output: ValidationError(func=base64, args={'value': 'cUSECm5YzcXJwP'}) Args: value: base64 string to validate. Returns: (Literal[True]): If `value` is a valid base64 encoding. (ValidationError): If `value` is an invalid base64 encoding. """ return ( re.match(r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$", value) if value else False ) slug.py 0000644 00000001356 15030212475 0006074 0 ustar 00 """Slug.""" # standard import re # local from .utils import validator @validator def slug(value: str, /): """Validate whether or not given value is valid slug. Valid slug can contain only lowercase alphanumeric characters and hyphens. It starts and ends with these lowercase alphanumeric characters. Examples: >>> slug('my-slug-2134') # Output: True >>> slug('my.slug') # Output: ValidationError(func=slug, args={'value': 'my.slug'}) Args: value: Slug string to validate. Returns: (Literal[True]): If `value` is a valid slug. (ValidationError): If `value` is an invalid slug. """ return re.match(r"^[a-z0-9]+(?:-[a-z0-9]+)*$", value) if value else False uri.py 0000644 00000003434 15030212475 0005720 0 ustar 00 """URI.""" # Read: https://stackoverflow.com/questions/176264 # https://www.rfc-editor.org/rfc/rfc3986#section-3 # local from .email import email from .url import url from .utils import validator def _file_url(value: str): if not value.startswith("file:///"): return False return True def _ipfs_url(value: str): if not value.startswith("ipfs://"): return False return True @validator def uri(value: str, /): """Return whether or not given value is a valid URI. Examples: >>> uri('mailto:example@domain.com') # Output: True >>> uri('file:path.txt') # Output: ValidationError(func=uri, ...) Args: value: URI to validate. Returns: (Literal[True]): If `value` is a valid URI. (ValidationError): If `value` is an invalid URI. """ if not value: return False # TODO: work on various validations # url if any( # fmt: off value.startswith(item) for item in { "ftp", "ftps", "git", "http", "https", "irc", "rtmp", "rtmps", "rtsp", "sftp", "ssh", "telnet", } # fmt: on ): return url(value) # email if value.startswith("mailto:"): return email(value.lstrip("mailto:")) # file if value.startswith("file:"): return _file_url(value) # ipfs if value.startswith("ipfs:"): return _ipfs_url(value) # magnet if value.startswith("magnet:?"): return True # telephone if value.startswith("tel:"): return True # data if value.startswith("data:"): return True # urn if value.startswith("urn:"): return True # urc if value.startswith("urc:"): return True return False between.py 0000644 00000004614 15030212475 0006553 0 ustar 00 """Between.""" # standard from datetime import datetime from typing import TypeVar, Union # local from ._extremes import AbsMax, AbsMin from .utils import validator PossibleValueTypes = TypeVar("PossibleValueTypes", int, float, str, datetime, None) @validator def between( value: PossibleValueTypes, /, *, min_val: Union[PossibleValueTypes, AbsMin, None] = None, max_val: Union[PossibleValueTypes, AbsMax, None] = None, ): """Validate that a number is between minimum and/or maximum value. This will work with any comparable type, such as floats, decimals and dates not just integers. This validator is originally based on [WTForms-NumberRange-Validator][1]. [1]: https://github.com/wtforms/wtforms/blob/master/src/wtforms/validators.py#L166-L220 Examples: >>> from datetime import datetime >>> between(5, min_val=2) # Output: True >>> between(13.2, min_val=13, max_val=14) # Output: True >>> between(500, max_val=400) # Output: ValidationError(func=between, args=...) >>> between( ... datetime(2000, 11, 11), ... min_val=datetime(1999, 11, 11) ... ) # Output: True Args: value: Value which is to be compared. min_val: The minimum required value of the number. If not provided, minimum value will not be checked. max_val: The maximum value of the number. If not provided, maximum value will not be checked. Returns: (Literal[True]): If `value` is in between the given conditions. (ValidationError): If `value` is not in between the given conditions. Raises: (ValueError): If `min_val` is greater than `max_val`. (TypeError): If there's a type mismatch during comparison. Note: - `PossibleValueTypes` = `TypeVar("PossibleValueTypes", int, float, str, datetime)` - If neither `min_val` nor `max_val` is provided, result will always be `True`. """ if value is None: return False if max_val is None: max_val = AbsMax() if min_val is None: min_val = AbsMin() try: if min_val > max_val: raise ValueError("`min_val` cannot be greater than `max_val`") except TypeError as err: raise TypeError("Comparison type mismatch") from err return min_val <= value <= max_val __init__.py 0000644 00000003753 15030212475 0006664 0 ustar 00 """Validate Anything!""" # local from .between import between from .card import amex, card_number, diners, discover, jcb, mastercard, unionpay, visa from .country import calling_code, country_code, currency from .cron import cron from .crypto_addresses import bsc_address, btc_address, eth_address, trx_address from .domain import domain from .email import email from .encoding import base16, base32, base58, base64 from .finance import cusip, isin, sedol from .hashes import md5, sha1, sha224, sha256, sha384, sha512 from .hostname import hostname from .i18n import ( es_cif, es_doi, es_nie, es_nif, fi_business_id, fi_ssn, fr_department, fr_ssn, ind_aadhar, ind_pan, ) from .iban import iban from .ip_address import ipv4, ipv6 from .length import length from .mac_address import mac_address from .slug import slug from .url import url from .utils import ValidationError, validator from .uuid import uuid __all__ = ( # ... "between", # crypto_addresses "bsc_address", "btc_address", "eth_address", "trx_address", # cards "amex", "card_number", "diners", "discover", "jcb", "mastercard", "visa", "unionpay", # country "calling_code", "country_code", "currency", # ... "cron", # ... "domain", # ... "email", # encodings "base16", "base32", "base58", "base64", # finance "cusip", "isin", "sedol", # hashes "md5", "sha1", "sha224", "sha256", "sha384", "sha512", # ... "hostname", # i18n "es_cif", "es_doi", "es_nie", "es_nif", "fi_business_id", "fi_ssn", "fr_department", "fr_ssn", "ind_aadhar", "ind_pan", # ... "iban", # ip_addresses "ipv4", "ipv6", # ... "length", # ... "mac_address", # ... "slug", # ... "url", # ... "uuid", # utils "ValidationError", "validator", ) __version__ = "0.33.0" _tld.txt 0000644 00000022633 15030212475 0006234 0 ustar 00 # Version 2024052400, Last Updated Fri May 24 07:07:01 2024 UTC AAA AARP ABB ABBOTT ABBVIE ABC ABLE ABOGADO ABUDHABI AC ACADEMY ACCENTURE ACCOUNTANT ACCOUNTANTS ACO ACTOR AD ADS ADULT AE AEG AERO AETNA AF AFL AFRICA AG AGAKHAN AGENCY AI AIG AIRBUS AIRFORCE AIRTEL AKDN AL ALIBABA ALIPAY ALLFINANZ ALLSTATE ALLY ALSACE ALSTOM AM AMAZON AMERICANEXPRESS AMERICANFAMILY AMEX AMFAM AMICA AMSTERDAM ANALYTICS ANDROID ANQUAN ANZ AO AOL APARTMENTS APP APPLE AQ AQUARELLE AR ARAB ARAMCO ARCHI ARMY ARPA ART ARTE AS ASDA ASIA ASSOCIATES AT ATHLETA ATTORNEY AU AUCTION AUDI AUDIBLE AUDIO AUSPOST AUTHOR AUTO AUTOS AW AWS AX AXA AZ AZURE BA BABY BAIDU BANAMEX BAND BANK BAR BARCELONA BARCLAYCARD BARCLAYS BAREFOOT BARGAINS BASEBALL BASKETBALL BAUHAUS BAYERN BB BBC BBT BBVA BCG BCN BD BE BEATS BEAUTY BEER BENTLEY BERLIN BEST BESTBUY BET BF BG BH BHARTI BI BIBLE BID BIKE BING BINGO BIO BIZ BJ BLACK BLACKFRIDAY BLOCKBUSTER BLOG BLOOMBERG BLUE BM BMS BMW BN BNPPARIBAS BO BOATS BOEHRINGER BOFA BOM BOND BOO BOOK BOOKING BOSCH BOSTIK BOSTON BOT BOUTIQUE BOX BR BRADESCO BRIDGESTONE BROADWAY BROKER BROTHER BRUSSELS BS BT BUILD BUILDERS BUSINESS BUY BUZZ BV BW BY BZ BZH CA CAB CAFE CAL CALL CALVINKLEIN CAM CAMERA CAMP CANON CAPETOWN CAPITAL CAPITALONE CAR CARAVAN CARDS CARE CAREER CAREERS CARS CASA CASE CASH CASINO CAT CATERING CATHOLIC CBA CBN CBRE CC CD CENTER CEO CERN CF CFA CFD CG CH CHANEL CHANNEL CHARITY CHASE CHAT CHEAP CHINTAI CHRISTMAS CHROME CHURCH CI CIPRIANI CIRCLE CISCO CITADEL CITI CITIC CITY CK CL CLAIMS CLEANING CLICK CLINIC CLINIQUE CLOTHING CLOUD CLUB CLUBMED CM CN CO COACH CODES COFFEE COLLEGE COLOGNE COM COMMBANK COMMUNITY COMPANY COMPARE COMPUTER COMSEC CONDOS CONSTRUCTION CONSULTING CONTACT CONTRACTORS COOKING COOL COOP CORSICA COUNTRY COUPON COUPONS COURSES CPA CR CREDIT CREDITCARD CREDITUNION CRICKET CROWN CRS CRUISE CRUISES CU CUISINELLA CV CW CX CY CYMRU CYOU CZ DABUR DAD DANCE DATA DATE DATING DATSUN DAY DCLK DDS DE DEAL DEALER DEALS DEGREE DELIVERY DELL DELOITTE DELTA DEMOCRAT DENTAL DENTIST DESI DESIGN DEV DHL DIAMONDS DIET DIGITAL DIRECT DIRECTORY DISCOUNT DISCOVER DISH DIY DJ DK DM DNP DO DOCS DOCTOR DOG DOMAINS DOT DOWNLOAD DRIVE DTV DUBAI DUNLOP DUPONT DURBAN DVAG DVR DZ EARTH EAT EC ECO EDEKA EDU EDUCATION EE EG EMAIL EMERCK ENERGY ENGINEER ENGINEERING ENTERPRISES EPSON EQUIPMENT ER ERICSSON ERNI ES ESQ ESTATE ET EU EUROVISION EUS EVENTS EXCHANGE EXPERT EXPOSED EXPRESS EXTRASPACE FAGE FAIL FAIRWINDS FAITH FAMILY FAN FANS FARM FARMERS FASHION FAST FEDEX FEEDBACK FERRARI FERRERO FI FIDELITY FIDO FILM FINAL FINANCE FINANCIAL FIRE FIRESTONE FIRMDALE FISH FISHING FIT FITNESS FJ FK FLICKR FLIGHTS FLIR FLORIST FLOWERS FLY FM FO FOO FOOD FOOTBALL FORD FOREX FORSALE FORUM FOUNDATION FOX FR FREE FRESENIUS FRL FROGANS FRONTIER FTR FUJITSU FUN FUND FURNITURE FUTBOL FYI GA GAL GALLERY GALLO GALLUP GAME GAMES GAP GARDEN GAY GB GBIZ GD GDN GE GEA GENT GENTING GEORGE GF GG GGEE GH GI GIFT GIFTS GIVES GIVING GL GLASS GLE GLOBAL GLOBO GM GMAIL GMBH GMO GMX GN GODADDY GOLD GOLDPOINT GOLF GOO GOODYEAR GOOG GOOGLE GOP GOT GOV GP GQ GR GRAINGER GRAPHICS GRATIS GREEN GRIPE GROCERY GROUP GS GT GU GUCCI GUGE GUIDE GUITARS GURU GW GY HAIR HAMBURG HANGOUT HAUS HBO HDFC HDFCBANK HEALTH HEALTHCARE HELP HELSINKI HERE HERMES HIPHOP HISAMITSU HITACHI HIV HK HKT HM HN HOCKEY HOLDINGS HOLIDAY HOMEDEPOT HOMEGOODS HOMES HOMESENSE HONDA HORSE HOSPITAL HOST HOSTING HOT HOTELS HOTMAIL HOUSE HOW HR HSBC HT HU HUGHES HYATT HYUNDAI IBM ICBC ICE ICU ID IE IEEE IFM IKANO IL IM IMAMAT IMDB IMMO IMMOBILIEN IN INC INDUSTRIES INFINITI INFO ING INK INSTITUTE INSURANCE INSURE INT INTERNATIONAL INTUIT INVESTMENTS IO IPIRANGA IQ IR IRISH IS ISMAILI IST ISTANBUL IT ITAU ITV JAGUAR JAVA JCB JE JEEP JETZT JEWELRY JIO JLL JM JMP JNJ JO JOBS JOBURG JOT JOY JP JPMORGAN JPRS JUEGOS JUNIPER KAUFEN KDDI KE KERRYHOTELS KERRYLOGISTICS KERRYPROPERTIES KFH KG KH KI KIA KIDS KIM KINDLE KITCHEN KIWI KM KN KOELN KOMATSU KOSHER KP KPMG KPN KR KRD KRED KUOKGROUP KW KY KYOTO KZ LA LACAIXA LAMBORGHINI LAMER LANCASTER LAND LANDROVER LANXESS LASALLE LAT LATINO LATROBE LAW LAWYER LB LC LDS LEASE LECLERC LEFRAK LEGAL LEGO LEXUS LGBT LI LIDL LIFE LIFEINSURANCE LIFESTYLE LIGHTING LIKE LILLY LIMITED LIMO LINCOLN LINK LIPSY LIVE LIVING LK LLC LLP LOAN LOANS LOCKER LOCUS LOL LONDON LOTTE LOTTO LOVE LPL LPLFINANCIAL LR LS LT LTD LTDA LU LUNDBECK LUXE LUXURY LV LY MA MADRID MAIF MAISON MAKEUP MAN MANAGEMENT MANGO MAP MARKET MARKETING MARKETS MARRIOTT MARSHALLS MATTEL MBA MC MCKINSEY MD ME MED MEDIA MEET MELBOURNE MEME MEMORIAL MEN MENU MERCKMSD MG MH MIAMI MICROSOFT MIL MINI MINT MIT MITSUBISHI MK ML MLB MLS MM MMA MN MO MOBI MOBILE MODA MOE MOI MOM MONASH MONEY MONSTER MORMON MORTGAGE MOSCOW MOTO MOTORCYCLES MOV MOVIE MP MQ MR MS MSD MT MTN MTR MU MUSEUM MUSIC MV MW MX MY MZ NA NAB NAGOYA NAME NATURA NAVY NBA NC NE NEC NET NETBANK NETFLIX NETWORK NEUSTAR NEW NEWS NEXT NEXTDIRECT NEXUS NF NFL NG NGO NHK NI NICO NIKE NIKON NINJA NISSAN NISSAY NL NO NOKIA NORTON NOW NOWRUZ NOWTV NP NR NRA NRW NTT NU NYC NZ OBI OBSERVER OFFICE OKINAWA OLAYAN OLAYANGROUP OLLO OM OMEGA ONE ONG ONL ONLINE OOO OPEN ORACLE ORANGE ORG ORGANIC ORIGINS OSAKA OTSUKA OTT OVH PA PAGE PANASONIC PARIS PARS PARTNERS PARTS PARTY PAY PCCW PE PET PF PFIZER PG PH PHARMACY PHD PHILIPS PHONE PHOTO PHOTOGRAPHY PHOTOS PHYSIO PICS PICTET PICTURES PID PIN PING PINK PIONEER PIZZA PK PL PLACE PLAY PLAYSTATION PLUMBING PLUS PM PN PNC POHL POKER POLITIE PORN POST PR PRAMERICA PRAXI PRESS PRIME PRO PROD PRODUCTIONS PROF PROGRESSIVE PROMO PROPERTIES PROPERTY PROTECTION PRU PRUDENTIAL PS PT PUB PW PWC PY QA QPON QUEBEC QUEST RACING RADIO RE READ REALESTATE REALTOR REALTY RECIPES RED REDSTONE REDUMBRELLA REHAB REISE REISEN REIT RELIANCE REN RENT RENTALS REPAIR REPORT REPUBLICAN REST RESTAURANT REVIEW REVIEWS REXROTH RICH RICHARDLI RICOH RIL RIO RIP RO ROCKS RODEO ROGERS ROOM RS RSVP RU RUGBY RUHR RUN RW RWE RYUKYU SA SAARLAND SAFE SAFETY SAKURA SALE SALON SAMSCLUB SAMSUNG SANDVIK SANDVIKCOROMANT SANOFI SAP SARL SAS SAVE SAXO SB SBI SBS SC SCB SCHAEFFLER SCHMIDT SCHOLARSHIPS SCHOOL SCHULE SCHWARZ SCIENCE SCOT SD SE SEARCH SEAT SECURE SECURITY SEEK SELECT SENER SERVICES SEVEN SEW SEX SEXY SFR SG SH SHANGRILA SHARP SHAW SHELL SHIA SHIKSHA SHOES SHOP SHOPPING SHOUJI SHOW SI SILK SINA SINGLES SITE SJ SK SKI SKIN SKY SKYPE SL SLING SM SMART SMILE SN SNCF SO SOCCER SOCIAL SOFTBANK SOFTWARE SOHU SOLAR SOLUTIONS SONG SONY SOY SPA SPACE SPORT SPOT SR SRL SS ST STADA STAPLES STAR STATEBANK STATEFARM STC STCGROUP STOCKHOLM STORAGE STORE STREAM STUDIO STUDY STYLE SU SUCKS SUPPLIES SUPPLY SUPPORT SURF SURGERY SUZUKI SV SWATCH SWISS SX SY SYDNEY SYSTEMS SZ TAB TAIPEI TALK TAOBAO TARGET TATAMOTORS TATAR TATTOO TAX TAXI TC TCI TD TDK TEAM TECH TECHNOLOGY TEL TEMASEK TENNIS TEVA TF TG TH THD THEATER THEATRE TIAA TICKETS TIENDA TIPS TIRES TIROL TJ TJMAXX TJX TK TKMAXX TL TM TMALL TN TO TODAY TOKYO TOOLS TOP TORAY TOSHIBA TOTAL TOURS TOWN TOYOTA TOYS TR TRADE TRADING TRAINING TRAVEL TRAVELERS TRAVELERSINSURANCE TRUST TRV TT TUBE TUI TUNES TUSHU TV TVS TW TZ UA UBANK UBS UG UK UNICOM UNIVERSITY UNO UOL UPS US UY UZ VA VACATIONS VANA VANGUARD VC VE VEGAS VENTURES VERISIGN VERSICHERUNG VET VG VI VIAJES VIDEO VIG VIKING VILLAS VIN VIP VIRGIN VISA VISION VIVA VIVO VLAANDEREN VN VODKA VOLVO VOTE VOTING VOTO VOYAGE VU WALES WALMART WALTER WANG WANGGOU WATCH WATCHES WEATHER WEATHERCHANNEL WEBCAM WEBER WEBSITE WED WEDDING WEIBO WEIR WF WHOSWHO WIEN WIKI WILLIAMHILL WIN WINDOWS WINE WINNERS WME WOLTERSKLUWER WOODSIDE WORK WORKS WORLD WOW WS WTC WTF XBOX XEROX XIHUAN XIN XN--11B4C3D XN--1CK2E1B XN--1QQW23A XN--2SCRJ9C XN--30RR7Y XN--3BST00M XN--3DS443G XN--3E0B707E XN--3HCRJ9C XN--3PXU8K XN--42C2D9A XN--45BR5CYL XN--45BRJ9C XN--45Q11C XN--4DBRK0CE XN--4GBRIM XN--54B7FTA0CC XN--55QW42G XN--55QX5D XN--5SU34J936BGSG XN--5TZM5G XN--6FRZ82G XN--6QQ986B3XL XN--80ADXHKS XN--80AO21A XN--80AQECDR1A XN--80ASEHDB XN--80ASWG XN--8Y0A063A XN--90A3AC XN--90AE XN--90AIS XN--9DBQ2A XN--9ET52U XN--9KRT00A XN--B4W605FERD XN--BCK1B9A5DRE4C XN--C1AVG XN--C2BR7G XN--CCK2B3B XN--CCKWCXETD XN--CG4BKI XN--CLCHC0EA0B2G2A9GCD XN--CZR694B XN--CZRS0T XN--CZRU2D XN--D1ACJ3B XN--D1ALF XN--E1A4C XN--ECKVDTC9D XN--EFVY88H XN--FCT429K XN--FHBEI XN--FIQ228C5HS XN--FIQ64B XN--FIQS8S XN--FIQZ9S XN--FJQ720A XN--FLW351E XN--FPCRJ9C3D XN--FZC2C9E2C XN--FZYS8D69UVGM XN--G2XX48C XN--GCKR3F0F XN--GECRJ9C XN--GK3AT1E XN--H2BREG3EVE XN--H2BRJ9C XN--H2BRJ9C8C XN--HXT814E XN--I1B6B1A6A2E XN--IMR513N XN--IO0A7I XN--J1AEF XN--J1AMH XN--J6W193G XN--JLQ480N2RG XN--JVR189M XN--KCRX77D1X4A XN--KPRW13D XN--KPRY57D XN--KPUT3I XN--L1ACC XN--LGBBAT1AD8J XN--MGB9AWBF XN--MGBA3A3EJT XN--MGBA3A4F16A XN--MGBA7C0BBN0A XN--MGBAAM7A8H XN--MGBAB2BD XN--MGBAH1A3HJKRD XN--MGBAI9AZGQP6J XN--MGBAYH7GPA XN--MGBBH1A XN--MGBBH1A71E XN--MGBC0A9AZCG XN--MGBCA7DZDO XN--MGBCPQ6GPA1A XN--MGBERP4A5D4AR XN--MGBGU82A XN--MGBI4ECEXP XN--MGBPL2FH XN--MGBT3DHD XN--MGBTX2B XN--MGBX4CD0AB XN--MIX891F XN--MK1BU44C XN--MXTQ1M XN--NGBC5AZD XN--NGBE9E0A XN--NGBRX XN--NODE XN--NQV7F XN--NQV7FS00EMA XN--NYQY26A XN--O3CW4H XN--OGBPF8FL XN--OTU796D XN--P1ACF XN--P1AI XN--PGBS0DH XN--PSSY2U XN--Q7CE6A XN--Q9JYB4C XN--QCKA1PMC XN--QXA6A XN--QXAM XN--RHQV96G XN--ROVU88B XN--RVC1E0AM3E XN--S9BRJ9C XN--SES554G XN--T60B56A XN--TCKWE XN--TIQ49XQYJ XN--UNUP4Y XN--VERMGENSBERATER-CTB XN--VERMGENSBERATUNG-PWB XN--VHQUV XN--VUQ861B XN--W4R85EL8FHU5DNRA XN--W4RS40L XN--WGBH1C XN--WGBL6A XN--XHQ521B XN--XKC2AL3HYE2A XN--XKC2DL3A5EE0H XN--Y9A3AQ XN--YFRO4I67O XN--YGBI2AMMX XN--ZFR164B XXX XYZ YACHTS YAHOO YAMAXUN YANDEX YE YODOBASHI YOGA YOKOHAMA YOU YOUTUBE YT YUN ZA ZAPPOS ZARA ZERO ZIP ZM ZONE ZUERICH ZW utils.py 0000644 00000006151 15030212475 0006260 0 ustar 00 """Utils.""" # standard from functools import wraps from inspect import getfullargspec from itertools import chain from os import environ from typing import Any, Callable, Dict class ValidationError(Exception): """Exception class when validation failure occurs.""" def __init__(self, function: Callable[..., Any], arg_dict: Dict[str, Any], message: str = ""): """Initialize Validation Failure.""" if message: self.reason = message self.func = function self.__dict__.update(arg_dict) def __repr__(self): """Repr Validation Failure.""" return ( f"ValidationError(func={self.func.__name__}, " + f"args={({k: v for (k, v) in self.__dict__.items() if k != 'func'})})" ) def __str__(self): """Str Validation Failure.""" return repr(self) def __bool__(self): """Bool Validation Failure.""" return False def _func_args_as_dict(func: Callable[..., Any], *args: Any, **kwargs: Any): """Return function's positional and key value arguments as an ordered dictionary.""" return dict( list(zip(dict.fromkeys(chain(getfullargspec(func)[0], kwargs.keys())), args)) + list(kwargs.items()) ) def validator(func: Callable[..., Any]): """A decorator that makes given function validator. Whenever the given `func` returns `False` this decorator returns `ValidationError` object. Examples: >>> @validator ... def even(value): ... return not (value % 2) >>> even(4) # Output: True >>> even(5) # Output: ValidationError(func=even, args={'value': 5}) Args: func: Function which is to be decorated. Returns: (Callable[..., ValidationError | Literal[True]]): A decorator which returns either `ValidationError` or `Literal[True]`. Raises: (ValidationError): If `r_ve` or `RAISE_VALIDATION_ERROR` is `True` """ @wraps(func) def wrapper(*args: Any, **kwargs: Any): raise_validation_error = False if "r_ve" in kwargs: raise_validation_error = True del kwargs["r_ve"] if environ.get("RAISE_VALIDATION_ERROR", "False") == "True": raise_validation_error = True try: if raise_validation_error: if func(*args, **kwargs): return True else: raise ValidationError(func, _func_args_as_dict(func, *args, **kwargs)) else: return ( True if func(*args, **kwargs) else ValidationError(func, _func_args_as_dict(func, *args, **kwargs)) ) except (ValueError, TypeError, UnicodeError) as exp: if raise_validation_error: raise ValidationError( func, _func_args_as_dict(func, *args, **kwargs), str(exp) ) from exp else: return ValidationError(func, _func_args_as_dict(func, *args, **kwargs), str(exp)) return wrapper
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings