tessl/pypi-flask-restplus

Fully featured framework for fast, easy and documented API development with Flask

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Overview

Eval results

Files

Input Validation

Name: tessl/pypi-flask-restplus
Author: tessl

Pre-built validation functions for common input types including emails, URLs, IP addresses, dates, and custom regular expression patterns. Flask-RESTPlus provides a comprehensive set of input validators that can be used with request parsing and field validation.

Capabilities

Network Address Validation

Functions for validating IP addresses and network-related inputs.

def ipv4(value):
    """
    Validate IPv4 addresses.
    
    Args:
        value (str): IP address string to validate
    
    Returns:
        str: Validated IPv4 address
    
    Raises:
        ValueError: If not a valid IPv4 address
    """

def ipv6(value):
    """
    Validate IPv6 addresses.
    
    Args:
        value (str): IP address string to validate
    
    Returns:
        str: Validated IPv6 address
    
    Raises:
        ValueError: If not a valid IPv6 address
    """

def ip(value):
    """
    Validate IP addresses (both IPv4 and IPv6).
    
    Args:
        value (str): IP address string to validate
    
    Returns:
        str: Validated IP address
    
    Raises:
        ValueError: If not a valid IP address
    """

Date and Time Validation

Functions for parsing and validating date and time formats.

def date(value):
    """
    Parse date strings in YYYY-MM-DD format.
    
    Args:
        value (str): Date string to parse
    
    Returns:
        datetime.date: Parsed date object
    
    Raises:
        ValueError: If not a valid date format
    """

def datetime_from_rfc822(value):
    """
    Parse RFC822 format datetime strings.
    
    Args:
        value (str): RFC822 datetime string
    
    Returns:
        datetime.datetime: Parsed datetime object
    
    Raises:
        ValueError: If not a valid RFC822 datetime
    """

def datetime_from_iso8601(value):
    """
    Parse ISO8601 format datetime strings.
    
    Args:
        value (str): ISO8601 datetime string
    
    Returns:
        datetime.datetime: Parsed datetime object
    
    Raises:
        ValueError: If not a valid ISO8601 datetime
    """

def date_from_iso8601(value):
    """
    Parse ISO8601 format date strings.
    
    Args:
        value (str): ISO8601 date string
    
    Returns:
        datetime.date: Parsed date object
    
    Raises:
        ValueError: If not a valid ISO8601 date
    """

def iso8601interval(value, argument='argument'):
    """
    Parse ISO8601 interval strings.
    
    Args:
        value (str): ISO8601 interval string
        argument (str): Argument name for error messages
    
    Returns:
        dict: Parsed interval with 'start' and 'end' datetime objects
    
    Raises:
        ValueError: If not a valid ISO8601 interval
    """

Numeric Validation

Functions for validating numeric inputs with constraints.

def natural(value, argument='argument'):
    """
    Validate natural numbers (non-negative integers >= 0).
    
    Args:
        value (str or int): Value to validate
        argument (str): Argument name for error messages
    
    Returns:
        int: Validated natural number
    
    Raises:
        ValueError: If not a natural number
    """

def positive(value, argument='argument'):
    """
    Validate positive integers (>= 1).
    
    Args:
        value (str or int): Value to validate
        argument (str): Argument name for error messages
    
    Returns:
        int: Validated positive integer
    
    Raises:
        ValueError: If not a positive integer
    """

def boolean(value):
    """
    Parse boolean values from various string representations.
    
    Accepts: 'true', 'false', '1', '0', 'yes', 'no', 'on', 'off' (case insensitive)
    
    Args:
        value (str or bool): Value to parse
    
    Returns:
        bool: Parsed boolean value
    
    Raises:
        ValueError: If not a valid boolean representation
    """

Validator Classes

Configurable validator classes for complex validation scenarios.

class URL:
    def __init__(self, check=False, ip=False, local=False, port=False, 
                 auth=False, schemes=None, domains=None, exclude=None):
        """
        Configurable URL validator.
        
        Args:
            check (bool): Perform additional URL checks
            ip (bool): Allow IP addresses as hostnames
            local (bool): Allow local/private URLs
            port (bool): Require port number
            auth (bool): Allow authentication in URL
            schemes (list, optional): Allowed URL schemes
            domains (list, optional): Allowed domains
            exclude (list, optional): Excluded domains
        """
    
    def __call__(self, value):
        """
        Validate URL string.
        
        Args:
            value (str): URL string to validate
        
        Returns:
            str: Validated URL
        
        Raises:
            ValueError: If URL doesn't meet validation criteria
        """

class email:
    def __init__(self, check=False, ip=False, local=False, domains=None, exclude=None):
        """
        Email address validator with domain checking.
        
        Args:
            check (bool): Perform additional email checks
            ip (bool): Allow IP addresses as domains
            local (bool): Allow local email addresses
            domains (list, optional): Allowed domains
            exclude (list, optional): Excluded domains
        """
    
    def __call__(self, value):
        """
        Validate email address.
        
        Args:
            value (str): Email address to validate
        
        Returns:
            str: Validated email address
        
        Raises:
            ValueError: If email doesn't meet validation criteria
        """

class regex:
    def __init__(self, pattern):
        """
        Regular expression validator.
        
        Args:
            pattern (str): Regular expression pattern
        """
    
    def __call__(self, value):
        """
        Validate value against regular expression.
        
        Args:
            value (str): Value to validate
        
        Returns:
            str: Validated value
        
        Raises:
            ValueError: If value doesn't match pattern
        """

class int_range:
    def __init__(self, low, high, argument='argument'):
        """
        Integer range validator.
        
        Args:
            low (int): Minimum value (inclusive)
            high (int): Maximum value (inclusive)
            argument (str): Argument name for error messages
        """
    
    def __call__(self, value):
        """
        Validate integer is within range.
        
        Args:
            value (str or int): Value to validate
        
        Returns:
            int: Validated integer
        
        Raises:
            ValueError: If integer is outside range
        """

Pre-configured Validators

Ready-to-use validator instances for common use cases.

url: URL  # Pre-configured URL validator instance

Time Constants

Constants for time-based validation and processing.

START_OF_DAY: datetime.time  # Time representing start of day (00:00:00)
END_OF_DAY: datetime.time    # Time representing end of day (23:59:59)

Usage Examples

Basic Input Validation

from flask_restplus import Api, Resource, reqparse, inputs

api = Api()

parser = reqparse.RequestParser()

# IP address validation
parser.add_argument('server_ip', type=inputs.ipv4, required=True)
parser.add_argument('client_ip', type=inputs.ip)  # IPv4 or IPv6

# Date validation
parser.add_argument('start_date', type=inputs.date)
parser.add_argument('created_at', type=inputs.datetime_from_iso8601)

# Numeric validation
parser.add_argument('page', type=inputs.natural, default=0)
parser.add_argument('count', type=inputs.positive, required=True)

# Boolean validation
parser.add_argument('active', type=inputs.boolean, default=True)

@api.route('/search')
class Search(Resource):
    @api.expect(parser)
    def get(self):
        args = parser.parse_args()
        return {
            'server_ip': args['server_ip'],
            'page': args['page'],
            'count': args['count'],
            'active': args['active']
        }

Email and URL Validation

from flask_restplus import reqparse, inputs

parser = reqparse.RequestParser()

# Basic email validation
parser.add_argument('email', type=inputs.email(), required=True)

# Email with domain restrictions
allowed_email = inputs.email(domains=['company.com', 'partner.org'])
parser.add_argument('work_email', type=allowed_email)

# Email excluding certain domains
restricted_email = inputs.email(exclude=['spam.com', 'temp-mail.org'])
parser.add_argument('user_email', type=restricted_email)

# Basic URL validation
parser.add_argument('website', type=inputs.url)

# URL with restrictions
secure_url = inputs.URL(schemes=['https'], check=True)
parser.add_argument('secure_website', type=secure_url)

# URL allowing local addresses
local_url = inputs.URL(local=True, ip=True)
parser.add_argument('internal_url', type=local_url)

Regular Expression Validation

from flask_restplus import reqparse, inputs

parser = reqparse.RequestParser()

# Phone number validation (US format)
phone_validator = inputs.regex(r'^\+?1?[2-9]\d{2}[2-9]\d{2}\d{4}$')
parser.add_argument('phone', type=phone_validator)

# Username validation (alphanumeric + underscore, 3-20 chars)
username_validator = inputs.regex(r'^[a-zA-Z0-9_]{3,20}$')
parser.add_argument('username', type=username_validator, required=True)

# Color hex code validation
color_validator = inputs.regex(r'^#[0-9A-Fa-f]{6}$')
parser.add_argument('color', type=color_validator)

# UUID validation
uuid_validator = inputs.regex(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$')
parser.add_argument('uuid', type=uuid_validator)

@api.route('/profile')
class Profile(Resource):
    @api.expect(parser)
    def post(self):
        args = parser.parse_args()
        return {'message': 'Profile updated', 'data': args}

Range Validation

from flask_restplus import reqparse, inputs

parser = reqparse.RequestParser()

# Age validation (0-150)
age_validator = inputs.int_range(0, 150, argument='age')
parser.add_argument('age', type=age_validator)

# Percentage validation (0-100)
percentage_validator = inputs.int_range(0, 100, argument='percentage')
parser.add_argument('completion', type=percentage_validator)

# Port number validation (1-65535)
port_validator = inputs.int_range(1, 65535, argument='port')
parser.add_argument('port', type=port_validator)

# Priority levels (1-10)
priority_validator = inputs.int_range(1, 10, argument='priority')
parser.add_argument('priority', type=priority_validator, default=5)

Date and Time Parsing

from flask_restplus import reqparse, inputs
from datetime import datetime, date

parser = reqparse.RequestParser()

# Simple date parsing (YYYY-MM-DD)
parser.add_argument('birth_date', type=inputs.date)

# ISO8601 datetime parsing
parser.add_argument('event_time', type=inputs.datetime_from_iso8601)

# RFC822 datetime parsing
parser.add_argument('mail_date', type=inputs.datetime_from_rfc822)

# ISO8601 interval parsing
parser.add_argument('time_range', type=inputs.iso8601interval)

@api.route('/events')
class Events(Resource):
    @api.expect(parser)
    def post(self):
        args = parser.parse_args()
        
        # dates are automatically parsed to Python objects
        birth_date = args['birth_date']  # datetime.date object
        event_time = args['event_time']  # datetime.datetime object
        
        return {
            'birth_date': birth_date.isoformat() if birth_date else None,
            'event_time': event_time.isoformat() if event_time else None,
            'age_years': (date.today() - birth_date).days // 365 if birth_date else None
        }

Custom Validation Functions

from flask_restplus import reqparse
import re

def validate_password(value):
    """
    Validate password strength.
    
    Requirements:
    - At least 8 characters
    - Contains uppercase and lowercase letters
    - Contains at least one digit
    - Contains at least one special character
    """
    if len(value) < 8:
        raise ValueError("Password must be at least 8 characters long")
    
    if not re.search(r'[A-Z]', value):
        raise ValueError("Password must contain at least one uppercase letter")
    
    if not re.search(r'[a-z]', value):
        raise ValueError("Password must contain at least one lowercase letter")
    
    if not re.search(r'\d', value):
        raise ValueError("Password must contain at least one digit")
    
    if not re.search(r'[!@#$%^&*(),.?":{}|<>]', value):
        raise ValueError("Password must contain at least one special character")
    
    return value

def validate_credit_card(value):
    """Validate credit card number using Luhn algorithm."""
    # Remove spaces and dashes
    card_number = re.sub(r'[^0-9]', '', value)
    
    if not card_number.isdigit():
        raise ValueError("Credit card number must contain only digits")
    
    if len(card_number) < 13 or len(card_number) > 19:
        raise ValueError("Credit card number must be 13-19 digits long")
    
    # Luhn algorithm
    def luhn_check(card_num):
        digits = [int(d) for d in card_num]
        for i in range(len(digits) - 2, -1, -2):
            digits[i] *= 2
            if digits[i] > 9:
                digits[i] -= 9
        return sum(digits) % 10 == 0
    
    if not luhn_check(card_number):
        raise ValueError("Invalid credit card number")
    
    return card_number

parser = reqparse.RequestParser()
parser.add_argument('password', type=validate_password, required=True)
parser.add_argument('card_number', type=validate_credit_card)

Boolean Input Handling

from flask_restplus import reqparse, inputs

parser = reqparse.RequestParser()

# Boolean inputs accept various formats
parser.add_argument('active', type=inputs.boolean)
parser.add_argument('verified', type=inputs.boolean, default=False)
parser.add_argument('premium', type=inputs.boolean)

@api.route('/user-settings')
class UserSettings(Resource):
    @api.expect(parser)
    def put(self):
        args = parser.parse_args()
        
        # These all work for boolean inputs:
        # active=true, active=True, active=1, active=yes, active=on
        # active=false, active=False, active=0, active=no, active=off
        
        return {
            'settings_updated': True,
            'active': args['active'],
            'verified': args['verified'],
            'premium': args['premium']
        }

Field Integration

from flask_restplus import Api, fields, inputs

api = Api()

# Using validators in field definitions
user_model = api.model('User', {
    'id': fields.Integer(required=True),
    'email': fields.String(required=True, validate=inputs.email()),
    'website': fields.String(validate=inputs.url),
    'age': fields.Integer(validate=inputs.int_range(13, 120, 'age')),
    'active': fields.Boolean(validate=inputs.boolean)
})

# Custom field with validation
class EmailField(fields.String):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.validate = inputs.email()

class URLField(fields.String):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.validate = inputs.URL(schemes=['http', 'https'])

# Using custom fields
profile_model = api.model('Profile', {
    'name': fields.String(required=True),
    'email': EmailField(required=True),
    'website': URLField(),
    'birth_date': fields.Date(validate=inputs.date)
})

Install with Tessl CLI