Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:58
📄 __init__.py """Validate Anything!""" # local from .between import between from .card import amex, card_number, diners, discover, jcb, mastercard, mir, 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, ru_inn, ) 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", "unionpay", "visa", "mir", # 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", "ru_inn", # ... "iban", # ip_addresses "ipv4", "ipv6", # ... "length", # ... "mac_address", # ... "slug", # ... "url", # ... "uuid", # utils "ValidationError", "validator", ) __version__ = "0.35.0"	2.02 KB	2025-05-25 12:26
📁 __pycache__	-	2025-05-25 12:26
📄 _extremes.py """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 maxsize >>> AbsMax() > AbsMin() True >>> AbsMax() > maxsize True >>> AbsMax() > 99999999999999999 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 maxsize >>> AbsMin() < -maxsize True >>> AbsMin() < None True >>> AbsMin() < '' True """ def __le__(self, other: Any): """LessThanOrEqual.""" return other is not AbsMin	996 B	2025-05-25 12:26
📄 _tld.txt # 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	9.4 KB	2025-05-25 12:26
📄 between.py """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) True >>> between(13.2, min_val=13, max_val=14) True >>> between(500, max_val=400) ValidationError(func=between, args={'value': 500, 'max_val': 400}) >>> between( ... datetime(2000, 11, 11), ... min_val=datetime(1999, 11, 11) ... ) 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	2.37 KB	2025-05-25 12:26
📄 card.py """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') True >>> card_number('4242424242424241') 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') True >>> visa('2223003122003222') 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') True >>> mastercard('4242424242424242') 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') True >>> amex('4242424242424242') 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') True >>> unionpay('4242424242424242') 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') True >>> diners('4242424242424242') 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') True >>> jcb('4242424242424242') 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') True >>> discover('4242424242424242') 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) @validator def mir(value: str, /): """Return whether or not given value is a valid Mir card number. Examples: >>> mir('2200123456789019') True >>> mir('4242424242424242') ValidationError(func=mir, args={'value': '4242424242424242'}) Args: value: Mir card number string to validate. Returns: (Literal[True]): If `value` is a valid Mir card number. (ValidationError): If `value` is an invalid Mir card number. """ pattern = re.compile(r"^(220[0-4])") return card_number(value) and len(value) == 16 and pattern.match(value)	6.08 KB	2025-05-25 12:26
📄 country.py """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') True >>> calling_code('-31') 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') ValidationError(func=country_code, args={'value': 'GB', 'iso_format': 'alpha3'}) >>> country_code('USA') True >>> country_code('840', iso_format='numeric') True >>> country_code('iN', iso_format='alpha2') ValidationError(func=country_code, args={'value': 'iN', 'iso_format': 'alpha2'}) >>> country_code('ZWE', iso_format='alpha3') 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') True >>> currency('ZWX') 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	14.63 KB	2025-05-25 12:26
📄 cron.py """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 * * ') True >>> cron('30-20 * * ') ValidationError(func=cron, args={'value': '30-20 * * *'}) 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	2.24 KB	2025-05-25 12:26
📁 crypto_addresses	-	2025-05-25 12:26
📄 domain.py """Domain.""" # standard from os import environ from pathlib import Path import re from typing import Optional, Set # local from .utils import validator class _IanaTLD: """Read IANA TLDs, and optionally cache them.""" _full_cache: Optional[Set[str]] = None # source: https://www.statista.com/statistics/265677 _popular_cache = {"COM", "ORG", "RU", "DE", "NET", "BR", "UK", "JP", "FR", "IT"} _popular_cache.add("ONION") @classmethod def _retrieve(cls): 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() @classmethod def check(cls, tld: str): if tld in cls._popular_cache: return True if cls._full_cache is None: if environ.get("PYVLD_CACHE_TLD") == "True": cls._full_cache = set(cls._retrieve()) else: return tld in cls._retrieve() return tld in cls._full_cache @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') True >>> domain('example.com/') ValidationError(func=domain, args={'value': 'example.com/'}) >>> # Supports IDN domains as well:: >>> domain('xn----gtbspbbmkef.xn--p1ai') 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 not _IanaTLD.check(value.rstrip(".").rsplit(".", 1)[-1].upper()): 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	3.08 KB	2025-05-25 12:26
📄 email.py """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') True >>> email('bogus@@') ValidationError(func=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\u00A0-\u00FF]" # dot-atom + r"\|[\u0100-\u017F\u0180-\u024F\u00A0-\u00FF0-9a-z!#$%&'+/=?^_`{}\|~\-]+" + r"(\.[\u0100-\u017F\u0180-\u024F\u00A0-\u00FF0-9a-z!#$%&'+/=?^_`{}\|~\-]+)$" # quoted-string + r'\|^"(' + r"[\u0100-\u017F\u0180-\u024F\u00A0-\u00FF\001-\010\013\014\016-\037" + r"!#-\[\]-\177]\|\\[\011.]" + r')*")$', username_part, re.IGNORECASE, ) else False )	2.9 KB	2025-05-25 12:26
📄 encoding.py """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') True >>> base16('a3f4Z1') 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======') True >>> base32('MfZW3zLT9Q======') 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') True >>> base58('cUSECm5YzcXJwP') True 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==') True >>> base64('cUSECm5YzcXJwP') 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 )	2.33 KB	2025-05-25 12:26
📄 finance.py """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') ValidationError(func=cusip, args={'value': '037833DP3'}) 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') ValidationError(func=isin, args={'value': '037833DP2'}) >>> isin('037833DP3') ValidationError(func=isin, args={'value': '037833DP3'}) 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') ValidationError(func=sedol, args={'value': '29A6922'}) 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	3.33 KB	2025-05-25 12:26
📄 hashes.py """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') True >>> md5('900zz11') 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') True >>> sha1('900zz11') 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') True >>> sha224('900zz11') 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' ... ) True >>> sha256('900zz11') 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' ... ) True >>> sha384('900zz11') 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' ... ) True >>> sha512('900zz11') 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	3.78 KB	2025-05-25 12:26
📄 hostname.py """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") True >>> hostname("this-pc") True >>> hostname("xn----gtbspbbmkef.xn--p1ai:65535") True >>> hostname("_example.com") ValidationError(func=hostname, args={'value': '_example.com'}) >>> hostname("123.5.77.88:31000") True >>> hostname("12.12.12.12") True >>> hostname("[::1]:22") True >>> hostname("dead:beef:0:0:0:0000:42:1") True >>> hostname("[0:0:0:0:0:ffff:1.2.3.4]:-65538") ValidationError(func=hostname, args={'value': '[0:0:0:0:0:ffff:1.2.3.4]:-65538'}) >>> hostname("[0:&:b:c:@:e:f::]:9999") ValidationError(func=hostname, args={'value': '[0:&:b:c:@:e:f::]:9999'}) 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)) )	4.09 KB	2025-05-25 12:26
📁 i18n	-	2025-05-25 12:26
📄 iban.py """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') True >>> iban('123456') ValidationError(func=iban, args={'value': '123456'}) 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 )	1.05 KB	2025-05-25 12:26
📄 ip_address.py """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') True >>> ipv4('1.1.1.1/8') True >>> ipv4('900.80.70.11') 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') True >>> ipv6('::1/128') True >>> ipv6('abc.0.0.1') 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	4.28 KB	2025-05-25 12:26
📄 length.py """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) True >>> length('something', min_val=9, max_val=9) True >>> length('something', max_val=5) ValidationError(func=length, args={'value': 'something', 'max_val': 5}) 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))	1.46 KB	2025-05-25 12:26
📄 mac_address.py """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') True >>> mac_address('00:00:00:00:00') 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	845 B	2025-05-25 12:26
📄 py.typed	0 B	2025-05-25 12:26
📄 slug.py """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') True >>> slug('my.slug') 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	730 B	2025-05-25 12:26
📄 uri.py """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') True >>> uri('file:path.txt') ValidationError(func=uri, args={'value': 'file:path.txt'}) 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[len("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	1.9 KB	2025-05-25 12:26
📄 url.py """URL.""" # standard from functools import lru_cache import re from typing import Callable, 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 # Adding "#", see https://github.com/python-validators/validators/issues/403 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, validate_scheme: Callable[[str], bool] = _validate_scheme, ): 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') True >>> url('ftp://foobar.dk') True >>> url('http://10.0.0.1') True >>> url('http://example.com/">user@example.com') ValidationError(func=url, args={'value': 'http://example.com/">user@example.com'}) 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). validate_scheme: Function that validates URL scheme. 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) )	7.64 KB	2025-05-25 12:26
📄 utils.py """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) True >>> even(5) 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	3.08 KB	2025-05-25 12:26
📄 uuid.py """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') True >>> uuid('2bc1c94f 0deb-43e9-92a1-4775189ec9f8') ValidationError(func=uuid, args={'value': '2bc1c94f 0deb-43e9-92a1-4775189ec9f8'}) 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	1.07 KB	2025-05-25 12:26

Edit File:

Terminal