Kosovo Phone Numbers: +383 Country Code, Format, Validation & Area Codes

import re

def validate_kosovo_phone(number):
    """Validate Kosovo phone number for all types."""
    patterns = {
        'mobile': r'^(\+383|0)?(4[3-9])\d{6}$',
        'landline': r'^(\+383|0)?(028|029|038|039|0280|0290|0390)\d{5,6}$',
        'toll_free': r'^(\+383|0)?800\d{5}$',
        'premium': r'^(\+383|0)?900\d{5}$'
    }

    # Remove spaces and hyphens
    cleaned = re.sub(r'[\s-]', '', number)

    for number_type, pattern in patterns.items():
        if re.match(pattern, cleaned):
            return {'valid': True, 'type': number_type, 'cleaned': cleaned}

    return {'valid': False, 'type': None, 'cleaned': cleaned}

# Test cases
print(validate_kosovo_phone('+383 44 123456'))  # Valid mobile
print(validate_kosovo_phone('038 123456'))       # Valid landline
print(validate_kosovo_phone('800 12345'))        # Valid toll-free

function validateKosovoPhone(number) {
  const patterns = {
    mobile: /^(\+383|0)?(4[3-9])\d{6}$/,
    landline: /^(\+383|0)?(028|029|038|039|0280|0290|0390)\d{5,6}$/,
    tollFree: /^(\+383|0)?800\d{5}$/,
    premium: /^(\+383|0)?900\d{5}$/
  };

  // Remove spaces and hyphens
  const cleaned = number.replace(/[\s-]/g, '');

  for (const [type, pattern] of Object.entries(patterns)) {
    if (pattern.test(cleaned)) {
      return { valid: true, type, cleaned };
    }
  }

  return { valid: false, type: null, cleaned };
}

function formatKosovoPhone(number) {
  try {
    // Remove all non-digit characters
    const cleaned = number.replace(/\D/g, '');

    // Check for valid length
    if (cleaned.length !== 8 && cleaned.length !== 11) {
      throw new Error('Invalid number length');
    }

    // Format based on number type
    const isInternational = cleaned.length === 11;
    return isInternational
      ? `+${cleaned.slice(0, 3)} ${cleaned.slice(3, 5)} ${cleaned.slice(5)}`
      : `0${cleaned.slice(0, 2)} ${cleaned.slice(2)}`; // Add leading 0 for national format
  } catch (error) {
    console.error('Phone formatting error:', error);
    return number; // Return original on error
  }
}

// Standard formats
formatKosovoPhone('+38344123456')    // Returns: +383 44 123456
formatKosovoPhone('044123456')        // Returns: 044 123456

// Edge cases
formatKosovoPhone('+383-44-123456')  // Returns: +383 44 123456
formatKosovoPhone('(044) 123456')    // Returns: 044 123456
formatKosovoPhone('invalid')          // Returns: invalid

import requests

def check_portability(phone_number):
    """Check if number has been ported to different carrier."""
    # Example API endpoint (replace with actual provider)
    api_url = "https://portability-api.example.com/lookup"

    response = requests.post(api_url, json={
        'phone_number': phone_number,
        'country_code': '383'
    })

    if response.status_code == 200:
        data = response.json()
        return {
            'original_carrier': data.get('original_carrier'),
            'current_carrier': data.get('current_carrier'),
            'ported': data.get('ported', False),
            'port_date': data.get('port_date')
        }

    return None

# Usage
result = check_portability('+38344123456')
if result and result['ported']:
    print(f"Number ported from {result['original_carrier']} to {result['current_carrier']}")

def is_golden_number(phone_number):
    """Detect golden number patterns."""
    # Extract subscriber portion (last 6 digits)
    digits = re.sub(r'\D', '', phone_number)[-6:]

    # Check for repeating digits
    if len(set(digits)) <= 2:
        return {'golden': True, 'pattern': 'repeating'}

    # Check for sequential
    if digits in '0123456789' or digits in '9876543210':
        return {'golden': True, 'pattern': 'sequential'}

    # Check for palindrome
    if digits == digits[::-1]:
        return {'golden': True, 'pattern': 'palindrome'}

    return {'golden': False, 'pattern': None}

CREATE TABLE blocked_numbers (
    id SERIAL PRIMARY KEY,
    phone_number VARCHAR(20) NOT NULL,
    block_type VARCHAR(20) NOT NULL, -- 'temporary' or 'permanent'
    reason VARCHAR(100) NOT NULL,
    blocked_at TIMESTAMP DEFAULT NOW(),
    blocked_until TIMESTAMP NULL,
    blocked_by VARCHAR(50),
    notes TEXT
);

CREATE INDEX idx_phone_lookup ON blocked_numbers(phone_number);

def check_blocked(phone_number):
    """Check if number is blocked."""
    query = """
        SELECT block_type, reason, blocked_until
        FROM blocked_numbers
        WHERE phone_number = %s
        AND (blocked_until IS NULL OR blocked_until > NOW())
    """

    result = execute_query(query, [phone_number])

    if result:
        return {
            'blocked': True,
            'type': result['block_type'],
            'reason': result['reason'],
            'until': result['blocked_until']
        }

    return {'blocked': False}

def block_number(phone_number, reason, block_type='permanent', duration_days=None):
    """Add number to blocklist."""
    blocked_until = None
    if block_type == 'temporary' and duration_days:
        blocked_until = datetime.now() + timedelta(days=duration_days)

    query = """
        INSERT INTO blocked_numbers
        (phone_number, block_type, reason, blocked_until)
        VALUES (%s, %s, %s, %s)
    """

    execute_query(query, [phone_number, block_type, reason, blocked_until])

def diagnose_format_issues(phone_number):
    """Identify specific formatting problems."""
    issues = []

    if not phone_number:
        return ['Empty number']

    # Check length
    digits_only = re.sub(r'\D', '', phone_number)
    if len(digits_only) < 8:
        issues.append(f'Too short: {len(digits_only)} digits (need 8)')
    elif len(digits_only) > 11:
        issues.append(f'Too long: {len(digits_only)} digits (max 11 with country code)')

    # Check country code
    if phone_number.startswith('+') and not phone_number.startswith('+383'):
        issues.append(f'Invalid country code (use +383)')

    # Check prefix
    if digits_only.startswith('383'):
        prefix = digits_only[3:5] if len(digits_only) > 5 else None
    elif digits_only.startswith('0'):
        prefix = digits_only[1:3] if len(digits_only) > 3 else None
    else:
        prefix = digits_only[:2] if len(digits_only) > 2 else None

    valid_prefixes = ['43', '44', '45', '46', '47', '48', '49', '28', '29', '38', '39']
    if prefix and prefix not in valid_prefixes:
        issues.append(f'Invalid prefix: {prefix}')

    return issues if issues else ['Valid format']

def detect_carrier(phone_number):
    """Identify carrier from number prefix."""
    digits = re.sub(r'\D', '', phone_number)

    # Extract prefix
    if digits.startswith('383'):
        prefix = digits[3:5]
    elif digits.startswith('0'):
        prefix = digits[1:3]
    else:
        prefix = digits[:2]

    carriers = {
        '44': 'Vala', '45': 'Vala', '46': 'Vala',
        '43': 'IPKO', '48': 'IPKO', '49': 'IPKO'
    }

    carrier = carriers.get(prefix, 'Unknown')

    # Check if ported (integrate with portability API)
    portability = check_portability(phone_number)
    if portability and portability['ported']:
        carrier = portability['current_carrier']

    return {'carrier': carrier, 'prefix': prefix, 'ported': portability['ported'] if portability else False}

def normalize_phone_number(phone_number):
    """Convert any Kosovo number format to E.164."""
    # Remove all non-digit characters except leading +
    cleaned = re.sub(r'[^\d+]', '', phone_number)

    # Remove leading zeros and add country code
    if cleaned.startswith('0'):
        cleaned = '+383' + cleaned[1:]
    elif not cleaned.startswith('+'):
        cleaned = '+383' + cleaned
    elif cleaned.startswith('+383383'):
        # Fix double country code
        cleaned = '+383' + cleaned[7:]

    return cleaned

# Examples
normalize_phone_number('044 123 456')      # Returns: +38344123456
normalize_phone_number('+383-44-123456')   # Returns: +38344123456
normalize_phone_number('44123456')         # Returns: +38344123456

import redis
from datetime import timedelta

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def get_carrier_cached(phone_number):
    """Get carrier info with Redis caching."""
    cache_key = f'carrier:{phone_number}'

    # Check cache first
    cached = redis_client.get(cache_key)
    if cached:
        return json.loads(cached)

    # Query portability database
    carrier_info = detect_carrier(phone_number)

    # Cache for 24 hours (adjust based on portability change frequency)
    redis_client.setex(cache_key, timedelta(hours=24), json.dumps(carrier_info))

    return carrier_info

from flask_limiter import Limiter
from flask import Flask

app = Flask(__name__)
limiter = Limiter(app, key_func=lambda: request.remote_addr)

@app.route('/api/validate', methods=['POST'])
@limiter.limit("100 per minute")
def validate_number():
    """Validate phone number with rate limiting."""
    phone_number = request.json.get('phone_number')
    return validate_kosovo_phone(phone_number)

from cryptography.fernet import Fernet

def encrypt_phone_number(phone_number, key):
    """Encrypt phone number for storage."""
    f = Fernet(key)
    return f.encrypt(phone_number.encode()).decode()

def decrypt_phone_number(encrypted_number, key):
    """Decrypt phone number."""
    f = Fernet(key)
    return f.decrypt(encrypted_number.encode()).decode()

def detect_suspicious_activity(phone_number, activity_log):
    """Flag suspicious patterns."""
    flags = []

    # Check call frequency
    recent_calls = [a for a in activity_log if a['timestamp'] > datetime.now() - timedelta(hours=1)]
    if len(recent_calls) > 50:
        flags.append('High call frequency')

    # Check for rapid carrier changes
    carrier_changes = [a for a in activity_log if a.get('event') == 'carrier_change']
    if len(carrier_changes) > 3:
        flags.append('Multiple carrier changes')

    return {'suspicious': len(flags) > 0, 'flags': flags}

def normalize_legacy_codes(phone_number):
    """Convert legacy Monaco/Slovenia codes to +383."""
    # Monaco code (Vala) - prefix 377
    if phone_number.startswith('+377') or phone_number.startswith('00377'):
        # Extract subscriber number and convert to +383 44/45/46
        subscriber = re.sub(r'\D', '', phone_number)[3:]
        return f'+38344{subscriber}'  # Default to Vala prefix

    # Slovenia code (IPKO) - prefix 386
    if phone_number.startswith('+386') or phone_number.startswith('00386'):
        # Extract subscriber number and convert to +383 43/48/49
        subscriber = re.sub(r'\D', '', phone_number)[3:]
        return f'+38343{subscriber}'  # Default to IPKO prefix

    return phone_number