Flags and Bitwise Operations

class Flag(Enum):
    def __or__(self, other):
        """Combine flags using bitwise OR (|)."""
    
    def __and__(self, other):
        """Test flags using bitwise AND (&)."""
    
    def __xor__(self, other):
        """Exclusive OR flags using bitwise XOR (^)."""
    
    def __invert__(self):
        """Invert flags using bitwise NOT (~)."""
    
    @property
    def _value_(self):
        """The numeric value of the flag."""
    
    @property
    def _name_(self):
        """The name of the flag."""

from aenum import Flag, auto

class Color(Flag):
    RED = auto()
    GREEN = auto()
    BLUE = auto()
    WHITE = RED | GREEN | BLUE

# Combining flags
purple = Color.RED | Color.BLUE
print(purple)  # Color.RED|BLUE

# Testing flags
print(Color.RED in purple)     # True
print(Color.GREEN in purple)   # False
print(bool(purple & Color.RED))  # True

# Complex combinations
print(Color.WHITE)             # Color.WHITE
print(Color.WHITE & Color.RED) # Color.RED

class IntFlag(int, Flag):
    def __init__(self, value):
        """
        Create an integer flag member.
        
        Args:
            value (int): Integer value for the flag member
        """
    
    def __new__(cls, value):
        """Create and return a new integer flag member."""
    
    def __or__(self, other):
        """Combine with integers or other flags."""
    
    def __and__(self, other):
        """Test with integers or other flags."""

from aenum import IntFlag

class Permission(IntFlag):
    READ = 4
    WRITE = 2
    EXECUTE = 1
    RWX = READ | WRITE | EXECUTE

# Integer operations
user_perms = Permission.READ | Permission.WRITE  # 6
print(user_perms)           # Permission.READ|WRITE
print(user_perms == 6)      # True
print(user_perms + 1)       # 7

# Permission checking
def has_permission(user_perms, required_perm):
    return bool(user_perms & required_perm)

print(has_permission(user_perms, Permission.READ))   # True
print(has_permission(user_perms, Permission.EXECUTE)) # False

class FlagBoundary(Enum):
    STRICT = 'strict'     # Raise ValueError for invalid values
    CONFORM = 'conform'   # Discard invalid bits, keep valid ones
    EJECT = 'eject'       # Return plain int for invalid values
    KEEP = 'keep'         # Keep all bits, even invalid ones

# Boundary constants
STRICT: FlagBoundary
CONFORM: FlagBoundary  
EJECT: FlagBoundary
KEEP: FlagBoundary

from aenum import IntFlag, STRICT, CONFORM, EJECT, KEEP

class StrictColor(IntFlag, boundary=STRICT):
    RED = 1
    GREEN = 2
    BLUE = 4

class FlexibleColor(IntFlag, boundary=CONFORM):
    RED = 1
    GREEN = 2
    BLUE = 4

# STRICT: raises ValueError for invalid values
try:
    color = StrictColor(8)  # Invalid value
except ValueError as e:
    print(f"Strict mode error: {e}")

# CONFORM: discards invalid bits
color = FlexibleColor(15)  # 15 = 1|2|4|8, but 8 is invalid
print(color)  # FlexibleColor.RED|GREEN|BLUE (8 discarded)

from aenum import IntFlag

class FileMode(IntFlag):
    # Owner permissions
    OWNER_READ = 0o400
    OWNER_WRITE = 0o200
    OWNER_EXECUTE = 0o100
    
    # Group permissions
    GROUP_READ = 0o040
    GROUP_WRITE = 0o020
    GROUP_EXECUTE = 0o010
    
    # Other permissions
    OTHER_READ = 0o004
    OTHER_WRITE = 0o002
    OTHER_EXECUTE = 0o001
    
    # Common combinations
    OWNER_ALL = OWNER_READ | OWNER_WRITE | OWNER_EXECUTE
    GROUP_READ_EXECUTE = GROUP_READ | GROUP_EXECUTE
    OTHER_READ_EXECUTE = OTHER_READ | OTHER_EXECUTE
    
    # Standard modes
    MODE_755 = OWNER_ALL | GROUP_READ_EXECUTE | OTHER_READ_EXECUTE
    MODE_644 = OWNER_READ | OWNER_WRITE | GROUP_READ | OTHER_READ

# Usage
file_mode = FileMode.MODE_755
print(oct(file_mode))  # 0o755
print(FileMode.OWNER_READ in file_mode)  # True

from aenum import Flag, auto

class Features(Flag):
    BETA_UI = auto()
    ADVANCED_SEARCH = auto()
    REAL_TIME_UPDATES = auto()
    DARK_MODE = auto()
    PREMIUM_FEATURES = auto()
    
    # Feature bundles
    BASIC = DARK_MODE
    PREMIUM = BETA_UI | ADVANCED_SEARCH | REAL_TIME_UPDATES | PREMIUM_FEATURES
    ALL = BETA_UI | ADVANCED_SEARCH | REAL_TIME_UPDATES | DARK_MODE | PREMIUM_FEATURES

def user_has_feature(user_features, feature):
    return bool(user_features & feature)

# User configuration
user_features = Features.PREMIUM
print(user_has_feature(user_features, Features.BETA_UI))  # True
print(user_has_feature(user_features, Features.DARK_MODE))  # False

from aenum import Flag

class HttpMethod(Flag):
    GET = 1
    POST = 2
    PUT = 4
    DELETE = 8
    PATCH = 16
    HEAD = 32
    OPTIONS = 64
    
    # Common combinations
    SAFE_METHODS = GET | HEAD | OPTIONS
    IDEMPOTENT_METHODS = GET | PUT | DELETE | HEAD | OPTIONS
    WRITE_METHODS = POST | PUT | DELETE | PATCH

def endpoint_supports(allowed_methods, method):
    return bool(allowed_methods & method)

# API endpoint configuration
api_endpoint_methods = HttpMethod.GET | HttpMethod.POST | HttpMethod.PUT
print(endpoint_supports(api_endpoint_methods, HttpMethod.GET))    # True
print(endpoint_supports(api_endpoint_methods, HttpMethod.DELETE)) # False

from aenum import Flag, auto

class Status(Flag):
    ACTIVE = auto()
    VERIFIED = auto() 
    PREMIUM = auto()
    ADMIN = auto()

user_status = Status.ACTIVE | Status.VERIFIED

# Check if user has all required flags
required = Status.ACTIVE | Status.VERIFIED
print((user_status & required) == required)  # True

# Check if user has any of the flags
any_premium = Status.PREMIUM | Status.ADMIN
print(bool(user_status & any_premium))  # False

from aenum import Flag, auto

class NetworkState(Flag):
    DISCONNECTED = 0
    CONNECTING = auto()
    CONNECTED = auto()
    AUTHENTICATED = auto()
    ENCRYPTED = auto()
    
    # Helper methods
    @classmethod
    def is_online(cls, state):
        return bool(state & (cls.CONNECTED | cls.AUTHENTICATED))
    
    @classmethod 
    def is_secure(cls, state):
        return bool(state & (cls.AUTHENTICATED | cls.ENCRYPTED))

# Usage
current_state = NetworkState.CONNECTED | NetworkState.AUTHENTICATED
print(NetworkState.is_online(current_state))  # True
print(NetworkState.is_secure(current_state))  # True

from aenum import IntFlag

class LoggingConfig(IntFlag):
    CONSOLE = 1
    FILE = 2  
    SYSLOG = 4
    EMAIL = 8
    DATABASE = 16
    
    # Preset combinations
    DEVELOPMENT = CONSOLE | FILE
    PRODUCTION = FILE | SYSLOG | EMAIL
    DEBUG = CONSOLE | FILE | DATABASE

logging_config = LoggingConfig.PRODUCTION
print(LoggingConfig.EMAIL in logging_config)  # True

from aenum import Flag, auto

class ValidationRules(Flag):
    REQUIRED = auto()
    NUMERIC = auto()
    EMAIL_FORMAT = auto()
    MIN_LENGTH = auto()
    MAX_LENGTH = auto()
    CUSTOM_PATTERN = auto()

def validate_field(value, rules):
    errors = []
    
    if ValidationRules.REQUIRED in rules and not value:
        errors.append("Field is required")
    
    if ValidationRules.NUMERIC in rules and not value.isdigit():
        errors.append("Field must be numeric")
    
    # Additional validation logic...
    return errors

# Usage
email_rules = ValidationRules.REQUIRED | ValidationRules.EMAIL_FORMAT
errors = validate_field("", email_rules)