
A library of string validators.
👑 Written in Nim language
nimble install valido / clue install valido
API reference
😍 Key Features
- Framework agnostic
- Mostly zero RegExp (format validators delegate to openparser)
- is
Base32, Base58, Base64 (standard and URL-safe)
- is
MD5
- is
Email
- is
Domain and SubDomain, with full IDN support (UTS #46, Punycode, NFC)
- is
IP4, IP6 (plus reachability checks)
- is
IBAN
- is
EAN8, EAN13 (with type detection via isEAN)
- is
CARD (BIN/IIN support for Visa, MasterCard, Maestro, Discovery, JCB, DinersClub, Mir, ChinaUnionPay, AmericanExpress)
- is Strong
Password
- is
Port
- is
URI, URL with 23+ per-scheme format validators
- is
UUID (versions 1 through 8, dashed or dashless, nil UUID)
- is
JSON, YAML, TOML
- is
Regex pattern and match
- is
Date, PastDate, FutureDate, Today with custom formats
- is
Lowercase, Uppercase, Alpha, Alphanumerical, Digits, Boolean, Int, Float, HexStr
- is
Length: isEmpty, isNotEmpty, isMin, isMax, isBetween
- is
Color: Hex, Rgb, Rgba, Hsl, Hsla, Hsv, Hwb, Cmyk, Lab, Lch, Oklab, Oklch, NamedColor, Transparent (CSS Color 4)
- is
Country and Swift (needs -d:validoExtras)
- Open Source |
MIT License
- Written in Nim language
Examples
Quick start
import valido
assert isEmail("office@example.com")
assert not isIP4("127.0.0.1") # loopback is opt-in
assert isIP4("127.0.0.1", allowLoopback = true)
assert not isStrongPassword("123adminAdmin")
Most validators return a plain bool. isUUID additionally accepts a version
selector, isUri accepts a scheme selector, and isEAN returns a
(status, type) tuple.
Text and strings
import valido
assert isLowercase("lorem")
assert isLowercase("lorem ipsum", withWhitespaces = true)
assert isLowercase("lorem ipsum 2023", true, true)
assert isUppercase("LOREM IPSUM", withWhitespaces = true)
assert isAlpha("abcdefgh")
assert isAlpha("no more lorem", withWhitespaces = true)
assert isAlphaNumeric("mystuff2")
assert isAlphaNumeric("one 2 3", withWhitespaces = true)
assert isDigits("1234554321")
assert isDigits("1234-554-321", '-') # allow a separator
assert isBoolean("true")
assert isFloat("20.99")
assert isInt("42")
assert isHexStr("48656c6c6f20576f726c64")
assert isEmpty("")
assert isNotEmpty("x")
assert isMin("hello", 3)
assert isMax("hello", 10)
assert isBetween("hello", (2, 8))
Encodings
import valido
assert isBase32("JBSWY3DPEBLW64TMMQQQ====")
assert isBase58("2NEpo7TZRRrLZSi2U")
assert isBase64("SGVsbG8gV29ybGQhIE5pbSBpcyBBd2Vzb21lIQ==")
assert isBase64("a-b_c", urlSafe = true)
assert isMD5("900150983cd24fb0d6963f7d28e17f72")
Network, email and hosts
import valido
assert isEmail("john-john@domain.dev")
assert isEmail("hey+2@example.com")
assert isEmail("x!y@example.com", allowSpecialChars = true)
assert isEmail("test@xn--mnchen-3ya.de") # Punycode is fine
assert isEmail("test@münchen.de", allowIdn = true) # SMTPUTF8
assert isDomain("example.com")
assert isIP4("8.8.8.8")
assert isIP6("2a00:1450:400d:80c::200e")
assert not isIP4Reachable("0.0.0.0", timeout = 1000) # performs a socket connect
assert isPort(8080)
assert isPort("3000")
assert isPort(80, strict = false) # 0..65535
assert isPort(8443, strict = true) # 1024..65535
Domains and IDN
isDomain validates a domain name with its Top-Level Domain, isSubDomain a
name that has a parent domain. Both run the input through
UTS #46 (Unicode IDNA Compatibility
Processing) with the tables of the current Unicode release, so internationalized
names are accepted in Unicode and in Punycode form, complete with NFC
normalization, Punycode round trips, right-to-left rules and the contextual
joiner rules.
import valido
# two labels, a name and a known TLD
assert isDomain("example.com")
assert isDomain("münchen.de")
assert isDomain("xn--mnchen-3ya.de") # the same name in Punycode
assert isDomain("XN--MNCHEN-3YA.DE") # DNS is case insensitive
assert isDomain("example.com") # fullwidth forms are mapped
assert isDomain("日本語.jp")
assert not isDomain("sub.example.com") # three labels, see isSubDomain
assert not isDomain("exam ple.com")
assert not isDomain("example.invalid") # unknown TLD
assert not isDomain("-example.com")
assert not isDomain("xn--ls8h.com") # an emoji label, IDNA2008 forbids it
# three labels or more, with a parent domain
assert isSubDomain("sub.example.com")
assert isSubDomain("a.b.c.example.com")
assert isSubDomain("www.münchen.de")
assert isSubDomain("example.co.uk") # country code suffixes
assert not isSubDomain("example.com")
# flags
assert isDomain("example.invalid", checkTld = false) # any TLD
assert isDomain("example.com.", allowTrailingDot = true) # fully qualified
assert isDomain("*.example.com", allowWildcard = true) # wildcard
assert isSubDomain("_dmarc.example.com", allowUnderscore = true)
assert isDomain("xn--ls8h.com", strict = false) # plain UTS #46, emoji allowed
assert toAscii("faß.de") == "xn--fa-hia.de" # nontransitional
assert toAscii("faß.de", transitional = true) == "fass.de"
The UTS #46 operations are available on their own:
import valido
assert toAscii("münchen.de") == "xn--mnchen-3ya.de"
assert toUnicode("xn--mnchen-3ya.de") == "münchen.de"
assert toNfc("a\u0308") == "ä"
assert punycodeEncode("münchen") == "xn--mnchen-3ya"
assert punycodeDecode("xn--mnchen-3ya") == "münchen"
assert isAce("xn--mnchen-3ya")
assert isIdn("münchen.de")
assert isNfc("ä")
# `toAscii` returns "" when a name cannot be processed, `tryToAscii` says why
let (ascii, ok) = tryToAscii("exam ple.de")
assert not ok
assert ascii == ""
URIs and URLs
isUri and isUrl dispatch to a per-scheme validator that checks the full
string format, not just the scheme name.
import valido
assert isUri("https://example.com/path?q=1#frag")
assert isUri("bitcoin:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa", SchemeURI.Bitcoin)
assert isUri("ftp://user@example.com/file.txt", SchemeURI.Ftp)
assert isWebUrl("https://user:pass@example.com:8080/path")
assert isUrl("http://example.com") # alias of isWebUrl
assert getScheme("https://example.com") == SchemeURI.Https
assert isFtpUri("ftp://user:pass@example.com:21/files")
assert isSftpUri("sftp://deploy@example.com/var/www/index.html")
assert isSshUri("ssh://deploy@192.168.1.1:22/var/www")
assert isGitUri("git://github.com/user/repo.git")
assert isGitUri("https://github.com/user/repo.git")
assert isMailto("mailto:hello@example.com")
assert isFileUri("file:///home/user/docs/file.txt")
assert isAndroidUri("android://com.example.app")
assert isBitcoinUri("bitcoin:1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa?amount=0.1&label=test")
assert isBitcoinCashUri("bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a")
assert isChromeUri("chrome://browser/content/browser.xul")
assert isChromeExtensionUri("chrome-extension://abcdefghijklmnopqrstuvwxyzabcdef/index.html")
assert isFaceTimeUri("facetime://+19995551234")
assert isFeedUri("feed://example.com/feed.xml")
assert isIrcUri("irc://irc.example.com:6697/#channel")
assert isIrc6Uri("irc6://irc.example.com/#channel")
assert isIrcsUri("ircs://irc.example.com/#channel")
assert isLdapsUri("ldaps://ldap.example.com:636/dc=example,dc=com")
assert isMongoDbUri("mongodb://user:pass@host1:27017,host2:27017/mydb?replicaSet=rs0")
assert isMarketUri("market://details?id=com.example.app")
assert isMessageUri("message:<1234@example.com>")
Data formats
import valido
assert isJSON("""{"name":"Albush","age":40}""")
assert isYaml("host: localhost\nport: 8080")
assert isYaml("- a\n- b\n- c")
assert isYamlStream("a: 1\n---\nb: 2")
assert isToml("[server]\nhost = \"localhost\"\nport = 8080")
isYaml and isToml delegate to openparser, so strictness follows those
parsers. A YAML plain scalar such as "hello" is valid YAML.
Regular expressions
import valido
assert isRegex("""(\w+)=(\w+)""")
assert not isRegex("*")
assert isRegexMatch("""(\w+)=(\w+)""", "foo=bar") # full input match
assert not isRegexMatch("""(\w+)=(\w+)""", "hello world")
UUIDs
import valido
assert isUUID("550e8400-e29b-41d4-a716-446655440000")
assert isUUID("550e8400-e29b-41d4-a716-446655440000", V4)
assert isUUID("550e8400e29b41d4a716446655440000") # dashless
assert not isUUID("550e8400e29b41d4a716446655440000", strictDashes = true)
assert isNilUUID("00000000-0000-0000-0000-000000000000")
Colors
CSS Color 4 is supported through openparser. isColor accepts any supported
notation, while the granular helpers only accept their own syntax.
import valido
assert isColor("red")
assert isColor("rebeccapurple")
assert isColor("#ff0000")
assert isColor("rgb(255 0 0 / 0.5)")
assert isColor("hsl(0 100% 50%)")
assert isColor("oklch(0.7 0.15 180)")
assert isColor("transparent")
assert isHex("#ff0000")
assert isHex("f00") # 3, 4, 6 or 8 digits, `#` optional
assert isHexColor("#ff000080")
assert isRgb("rgb(255, 0, 0)")
assert isRgba("rgba(255, 0, 0, 0.5)")
assert isRgba("rgb(255 0 0 / 0.5)")
assert isHsl("hsl(0, 100%, 50%)")
assert isHsla("hsla(0, 100%, 50%, 0.5)")
assert isHsv("hsv(120, 100%, 100%)")
assert isHwb("hwb(120 20% 20%)")
assert isCmyk("cmyk(0%, 100%, 100%, 0%)")
assert isLab("lab(53.2 80.1 67.2)")
assert isLch("lch(54.3 106.8 40.9)")
assert isOklab("oklab(0.628 0.225 0.126)")
assert isOklch("oklch(0.7 0.15 180)")
assert isNamedColor("RebeccaPurple") # case-insensitive
assert isTransparent("transparent")
Dates
import valido
assert isDate("2023-01-05")
assert isDate("2023-01-05 2:30pm", "yyyy-MM-dd h:mtt")
assert isPastDate("2022-01-03")
assert isFutureDate("2030-03-03")
assert isToday("2026-09-24")
Finance and commerce
import valido
assert isIBAN("BE71096123456769")
assert isEAN8("40123455")
assert isEAN13("1234567690124")
assert isEAN("1234567690124") == (true, EAN13) # returns status and type
assert isCard("4111111111111111") # Luhn check
assert isVisa("4111111111111111")
assert isMasterCard("2222400050000009")
assert isMaestro("6759649826438453")
assert isAmericanExpress("371449635398431")
assert isAMEX("340000000000009")
assert isDiscover("6011111111111117")
assert isJCB("3530111333300000")
assert isDinersClub("30569309025904")
assert isMir("2200000000000004")
assert isChinaUnionPay("6221260000000000")
Security
import valido
assert isStrongPassword("x6y2C8D@#$(t5Lgg")
assert not isStrongPassword("123adminAdmin")
assert isStrongPassword("correct-horse-Battery-9!", defaultEntropy = 4.0)
Extra features
The country and SWIFT reference data is opt-in, because it embeds a few
megabytes of data into your binary. Enable it at compile time:
Without the flag none of the names below exist, so a default build stays
small. With it enabled you get full country reference data (names, ISO and
IOC codes, capitals, TLDs, languages, currencies, phone codes, mobile
prefixes, postal formats and subdivisions) and validation for over 110,000
SWIFT/BIC codes.
The data is embedded at compile time, so nothing is read from disk at
runtime. It is parsed on first use, not at program start, so a program that
never calls these functions pays nothing. The first call takes roughly half
a second in a release build and is noticeably slower in a debug build.
A program that actually uses these validators grows by about 12MB, the size
of the embedded data. A program that enables the flag but never calls into
it is unaffected, because the data is dropped at link time.
import valido
# Country codes: alpha-2, alpha-3, ISO numeric and IOC
assert isCountry("US")
assert isCountry("usa")
assert isCountry("840")
assert not isCountry("XX")
# Names, capitals, TLDs, currencies and languages
assert isCountryName("Canada")
assert isCapital("Washington")
assert isCountryTld(".us")
assert isCurrencyCode("USD")
assert isLanguageCode("eng")
assert isPhoneCode("1")
# Full record access
let us = getCountry("US")
assert us.info.alpha3 == "USA"
assert us.info.capital == "Washington"
assert "USD" in us.currency.code
assert 10 in us.phone.length
assert us.postal.regex == "^[0-9]{5}([0-9]{4})?$"
assert us.states["NY"] == "New York"
assert getCountries().len > 250
# Country-aware formats
assert isState("NY", "US")
assert isPostalCode("10001", "US")
assert isPostalCode("K1A 0B1", "CA")
assert isMobile("+1 201 555 0123", "US")
# SWIFT / BIC
assert isSwift("BOFAUS3N")
assert isSwift("bofa us3n")
assert not isSwift("ZZZZZZZZ")
let bank = getSwift("BOFAUS3N")
assert bank.name == "BANK OF AMERICA, N.A."
assert bank.city == "NEW YORK,NY"
❤ Contributions & Support
🎩 License
Valido | MIT license. Made by Humans from OpenPeeps.
Copyright © OpenPeeps & Contributors — All rights reserved.