WPS国际版深度体验：海外用户的完美中文办公解决方案

class InternationalizationEngine:
    """国际化引擎深度分析"""
    
    def __init__(self):
        self.supported_languages = {
            'en': 'English',
            'zh-CN': '简体中文', 
            'zh-TW': '繁體中文',
            'ja': '日本語',
            'ko': '한국어',
            'fr': 'Français',
            'de': 'Deutsch',
            'es': 'Español',
            'ru': 'Русский',
            'ar': 'العربية'
        }
        self.current_language = 'en'
    
    def analyze_language_switching(self):
        """分析语言切换机制"""
        switching_features = {
            '自动检测': [
                '根据系统语言自动适配',
                'IP地理位置智能推荐',
                '文档内容语言识别'
            ],
            '手动切换': [
                '设置界面一键切换',
                '无需重启立即生效',
                '界面元素完整翻译'
            ],
            '混合模式': [
                '界面英文+中文输入',
                '多语言文档协同编辑',
                '实时翻译辅助'
            ]
        }
        return switching_features
    
    def switch_interface_language(self, target_language, user_location):
        """切换界面语言"""
        try:
            # 验证语言支持
            if target_language not in self.supported_languages:
                # 回退到英语
                target_language = 'en'
            
            # 应用语言设置
            self._apply_language_settings(target_language)
            
            # 适配区域设置
            regional_settings = self._get_regional_settings(
                target_language, user_location
            )
            self._apply_regional_settings(regional_settings)
            
            # 更新字体配置
            self._update_font_configuration(target_language)
            
            print(f"界面语言已切换到: {self.supported_languages[target_language]}")
            return True
            
        except Exception as e:
            print(f"语言切换失败: {e}")
            return False
    
    def _get_regional_settings(self, language, location):
        """获取区域设置"""
        regional_configs = {
            'en': {
                'date_format': 'MM/DD/YYYY',
                'time_format': '12小时制',
                'currency_symbol': '$',
                'paper_size': 'Letter'
            },
            'zh-CN': {
                'date_format': 'YYYY-MM-DD',
                'time_format': '24小时制', 
                'currency_symbol': '¥',
                'paper_size': 'A4'
            },
            'ja': {
                'date_format': 'YYYY年MM月DD日',
                'time_format': '24小时制',
                'currency_symbol': '¥',
                'paper_size': 'A4'
            }
        }
        
        # 根据地理位置进行微调
        base_config = regional_configs.get(language, regional_configs['en'])
        return self._adjust_for_location(base_config, location)

class InputMethodIntegration:
    """输入法集成系统"""
    
    def __init__(self):
        self.supported_input_methods = [
            'Sogou Pinyin',
            'Google Pinyin', 
            'Microsoft Pinyin',
            'RIME',
            'Cangjie',
            'Boshiamy'
        ]
    
    def configure_chinese_input(self, user_preferences):
        """配置中文输入环境"""
        configuration = {
            'input_method': user_preferences.get('input_method', 'System Default'),
            'simplified_traditional': user_preferences.get('character_set', 'simplified'),
            'punctuation_style': user_preferences.get('punctuation', 'chinese'),
            'auto_correction': user_preferences.get('auto_correct', True),
            'cloud_association': user_preferences.get('cloud_assist', True)
        }
        
        # 应用配置
        self._apply_input_configuration(configuration)
        
        return configuration
    
    def handle_mixed_language_document(self, document_content):
        """处理混合语言文档"""
        analysis_results = {
            'language_distribution': self._analyze_language_distribution(document_content),
            'font_consistency': self._check_font_consistency(document_content),
            'formatting_issues': self._detect_formatting_issues(document_content),
            'compatibility_warnings': self._check_compatibility_warnings(document_content)
        }
        
        # 自动修复建议
        fixes = self._generate_auto_fix_suggestions(analysis_results)
        analysis_results['auto_fix_suggestions'] = fixes
        
        return analysis_results
    
    def real_time_translation_assist(self, selected_text, source_lang, target_lang):
        """实时翻译辅助"""
        try:
            # 调用翻译服务
            translation_result = self._call_translation_service(
                selected_text, source_lang, target_lang
            )
            
            # 提供替换建议
            replacement_suggestions = self._generate_replacement_suggestions(
                selected_text, translation_result
            )
            
            return {
                'translated_text': translation_result,
                'suggestions': replacement_suggestions,
                'confidence_score': self._calculate_translation_confidence(
                    selected_text, translation_result
                )
            }
            
        except Exception as e:
            print(f"翻译辅助失败: {e}")
            return None

class DocumentCompatibilityAnalyzer:
    """文档兼容性分析器"""
    
    def __init__(self):
        self.supported_formats = {
            '文字处理': ['.doc', '.docx', '.wps', '.txt', '.rtf', '.odt'],
            '电子表格': ['.xls', '.xlsx', '.et', '.csv', '.ods'],
            '演示文稿': ['.ppt', '.pptx', '.dps', '.odp'],
            'PDF相关': ['.pdf', '.ofd'],
            '其他格式': ['.html', '.xml', '.mht']
        }
    
    def test_format_compatibility(self, test_documents):
        """测试格式兼容性"""
        compatibility_results = {}
        
        for doc_category, formats in self.supported_formats.items():
            category_results = {}
            
            for file_format in formats:
                test_files = [
                    f for f in test_documents 
                    if f.lower().endswith(file_format)
                ]
                
                format_results = []
                for test_file in test_files:
                    result = self._test_single_file_compatibility(test_file)
                    format_results.append(result)
                
                # 计算兼容性评分
                compatibility_score = self._calculate_compatibility_score(format_results)
                category_results[file_format] = {
                    'score': compatibility_score,
                    'details': format_results
                }
            
            compatibility_results[doc_category] = category_results
        
        return compatibility_results
    
    def _test_single_file_compatibility(self, file_path):
        """测试单个文件兼容性"""
        try:
            # 打开文件
            file_extension = os.path.splitext(file_path)[1].lower()
            doc = self._open_document(file_path, file_extension)
            
            # 检查内容完整性
            content_integrity = self._check_content_integrity(doc, file_extension)
            
            # 检查格式保持度
            format_preservation = self._check_format_preservation(doc, file_extension)
            
            # 检查功能可用性
            feature_availability = self._check_feature_availability(doc, file_extension)
            
            doc.Close()
            
            return {
                'file_name': os.path.basename(file_path),
                'content_integrity': content_integrity,
                'format_preservation': format_preservation,
                'feature_availability': feature_availability,
                'overall_score': self._calculate_overall_score(
                    content_integrity, format_preservation, feature_availability
                )
            }
            
        except Exception as e:
            return {
                'file_name': os.path.basename(file_path),
                'error': str(e),
                'overall_score': 0
            }

class MicrosoftOfficeCompatibility:
    """Microsoft Office兼容性测试"""
    
    def __init__(self):
        self.office_versions = [
            'Office 365',
            'Office 2021', 
            'Office 2019',
            'Office 2016',
            'Office 2013'
        ]
    
    def run_advanced_compatibility_test(self):
        """运行高级兼容性测试"""
        test_scenarios = [
            self._test_complex_formatting,
            self._test_advanced_charts,
            self._test_macros_vba,
            self._test_embedded_objects,
            self._test_advanced_animations
        ]
        
        results = {}
        for test_scenario in test_scenarios:
            scenario_name = test_scenario.__name__
            try:
                result = test_scenario()
                results[scenario_name] = {
                    'status': '完成',
                    'result': result
                }
            except Exception as e:
                results[scenario_name] = {
                    'status': '错误',
                    'error': str(e)
                }
        
        return results
    
    def _test_complex_formatting(self):
        """测试复杂格式兼容性"""
        formatting_tests = [
            '多级列表和编号',
            '样式和主题应用',
            '表格样式和格式',
            '页眉页脚复杂性',
            '分栏和版面设计'
        ]
        
        test_results = {}
        for test_item in formatting_tests:
            # 创建测试文档
            test_doc = self._create_test_document(test_item)
            
            # 在WPS中打开并检查
            wps_result = self._open_in_wps(test_doc)
            
            # 在Word中打开并检查  
            word_result = self._open_in_word(test_doc)
            
            # 比较结果
            comparison = self._compare_results(wps_result, word_result)
            test_results[test_item] = comparison
        
        return test_results
    
    def handle_compatibility_issues(self, issue_type, document_path):
        """处理兼容性问题"""
        issue_handlers = {
            'formatting_lost': self._fix_formatting_issues,
            'font_substitution': self._handle_font_substitution,
            'layout_changes': self._adjust_layout_compatibility,
            'feature_unsupported': self._provide_alternative_solutions
        }
        
        handler = issue_handlers.get(issue_type)
        if handler:
            return handler(document_path)
        else:
            return self._general_compatibility_fix(document_path)

class GlobalNetworkOptimizer:
    """全球网络优化器"""
    
    def __init__(self):
        self.cdn_nodes = {
            '北美': ['us-east-1', 'us-west-1', 'ca-central-1'],
            '欧洲': ['eu-west-1', 'eu-central-1', 'uk-south-1'],
            '亚洲': ['ap-east-1', 'ap-southeast-1', 'jp-east-1'],
            '大洋洲': ['au-east-1', 'nz-north-1']
        }
        self.current_node = None
    
    def optimize_connection(self, user_location, service_type):
        """优化连接路线"""
        try:
            # 检测用户位置
            detected_location = self._detect_user_location(user_location)
            
            # 选择最优节点
            optimal_node = self._select_optimal_node(detected_location, service_type)
            
            # 建立加速连接
            connection_params = self._establish_accelerated_connection(optimal_node)
            
            # 测试连接质量
            connection_quality = self._test_connection_quality(connection_params)
            
            if connection_quality['score'] >= 0.8:
                self.current_node = optimal_node
                return {
                    'status': '优化成功',
                    'selected_node': optimal_node,
                    'latency': connection_quality['latency'],
                    'throughput': connection_quality['throughput']
                }
            else:
                return self._fallback_to_alternative(connection_quality)
                
        except Exception as e:
            print(f"网络优化失败: {e}")
            return self._enable_offline_mode()
    
    def _select_optimal_node(self, location, service_type):
        """选择最优CDN节点"""
        # 基于地理位置的节点选择
        region_nodes = {
            'North America': self.cdn_nodes['北美'],
            'Europe': self.cdn_nodes['欧洲'], 
            'Asia': self.cdn_nodes['亚洲'],
            'Oceania': self.cdn_nodes['大洋洲']
        }
        
        user_region = self._map_location_to_region(location)
        candidate_nodes = region_nodes.get(user_region, self.cdn_nodes['北美'])
        
        # 基于服务类型的优化
        if service_type == 'document_sync':
            # 文档同步需要低延迟
            return self._select_low_latency_node(candidate_nodes)
        elif service_type == 'large_file_transfer':
            # 大文件传输需要高带宽
            return self._select_high_bandwidth_node(candidate_nodes)
        else:
            return candidate_nodes[0]

class GlobalCollaborationSystem:
    """全球协作系统"""
    
    def __init__(self, network_optimizer):
        self.network_optimizer = network_optimizer
        self.collaboration_sessions = {}
    
    def start_global_collaboration(self, document_path, participants):
        """启动全球协作会话"""
        try:
            # 创建协作会话
            session_id = self._generate_session_id()
            collaboration_session = {
                'session_id': session_id,
                'document_path': document_path,
                'participants': participants,
                'start_time': datetime.now(),
                'status': 'active'
            }
            
            # 为每个参与者优化连接
            for participant in participants:
                optimized_connection = self.network_optimizer.optimize_connection(
                    participant['location'], 'realtime_collaboration'
                )
                participant['connection_info'] = optimized_connection
            
            # 上传文档到云端
            cloud_document = self._upload_to_cloud_storage(document_path, session_id)
            
            # 建立实时通信通道
            realtime_channel = self._establish_realtime_communication(participants)
            
            collaboration_session.update({
                'cloud_document': cloud_document,
                'realtime_channel': realtime_channel
            })
            
            self.collaboration_sessions[session_id] = collaboration_session
            
            # 通知所有参与者
            self._notify_participants(participants, session_id)
            
            return session_id
            
        except Exception as e:
            print(f"启动协作会话失败: {e}")
            return None
    
    def handle_cross_region_latency(self, session_id, operations):
        """处理跨区域延迟"""
        session = self.collaboration_sessions.get(session_id)
        if not session:
            return None
        
        # 操作批处理以减少网络请求
        batched_operations = self._batch_operations(operations)
        
        # 冲突检测和解决
        conflict_resolution = self._detect_and_resolve_conflicts(
            session, batched_operations
        )
        
        # 应用操作转换以处理乱序到达
        transformed_operations = self._apply_operational_transformation(
            batched_operations, conflict_resolution
        )
        
        return transformed_operations
    
    def realtime_language_translation(self, chat_messages, target_languages):
        """实时语言翻译"""
        translated_messages = {}
        
        for message in chat_messages:
            original_lang = self._detect_language(message['content'])
            user_lang = message['user_language']
            
            if original_lang != user_lang:
                # 需要翻译
                translated_content = self._translate_text(
                    message['content'], original_lang, user_lang
                )
                translated_messages[message['user_id']] = translated_content
            else:
                translated_messages[message['user_id']] = message['content']
        
        return translated_messages

class GlobalPaymentProcessor:
    """全球支付处理器"""
    
    def __init__(self):
        self.supported_currencies = [
            'USD', 'EUR', 'GBP', 'JPY', 'CAD', 'AUD', 
            'CNY', 'HKD', 'TWD', 'SGD', 'KRW'
        ]
        self.payment_methods = [
            'credit_card',
            'paypal', 
            'alipay_global',
            'wechat_pay_overseas',
            'apple_pay',
            'google_pay'
        ]
    
    def process_international_payment(self, payment_request):
        """处理国际支付"""
        try:
            # 验证支付信息
            validation_result = self._validate_payment_request(payment_request)
            if not validation_result['valid']:
                return {
                    'status': 'validation_failed',
                    'errors': validation_result['errors']
                }
            
            # 货币转换
            converted_amount = self._convert_currency(
                payment_request['amount'],
                payment_request['from_currency'],
                payment_request['to_currency']
            )
            
            # 执行支付
            payment_result = self._execute_payment(
                payment_request['payment_method'],
                converted_amount,
                payment_request['payment_details']
            )
            
            # 处理3D安全验证
            if payment_result.get('requires_3d_secure'):
                secure_result = self._handle_3d_secure(payment_request)
                payment_result.update(secure_result)
            
            # 记录交易
            self._record_transaction(payment_request, payment_result)
            
            return {
                'status': 'success',
                'transaction_id': payment_result['transaction_id'],
                'amount_charged': converted_amount,
                'currency': payment_request['to_currency']
            }
            
        except Exception as e:
            print(f"支付处理失败: {e}")
            return {
                'status': 'error',
                'error_message': str(e)
            }
    
    def _convert_currency(self, amount, from_currency, to_currency):
        """货币转换"""
        exchange_rates = self._get_current_exchange_rates()
        
        if from_currency == to_currency:
            return amount
        
        if from_currency not in exchange_rates or to_currency not in exchange_rates:
            raise ValueError("不支持的货币类型")
        
        # 转换为基准货币（USD）
        usd_amount = amount / exchange_rates[from_currency]
        
        # 转换为目标货币
        target_amount = usd_amount * exchange_rates[to_currency]
        
        # 四舍五入到小数点后两位
        return round(target_amount, 2)

class RegionalPricingStrategy:
    """区域性定价策略"""
    
    def __init__(self):
        self.pricing_tiers = {
            'premium': {
                '北美': 99.99,
                '欧洲': 89.99,
                '亚洲': 79.99,
                '发展中国家': 49.99
            },
            'professional': {
                '北美': 69.99,
                '欧洲': 59.99, 
                '亚洲': 49.99,
                '发展中国家': 29.99
            },
            'student': {
                'global': 19.99
            }
        }
    
    def calculate_localized_price(self, plan_type, user_region, user_category):
        """计算本地化价格"""
        try:
            # 获取基础价格
            if plan_type not in self.pricing_tiers:
                raise ValueError(f"无效的计划类型: {plan_type}")
            
            regional_prices = self.pricing_tiers[plan_type]
            
            # 学生全球统一价
            if user_category == 'student' and 'global' in regional_prices:
                base_price = regional_prices['global']
            else:
                base_price = regional_prices.get(user_region, regional_prices['北美'])
            
            # 应用区域性折扣
            discounted_price = self._apply_regional_discounts(
                base_price, user_region, user_category
            )
            
            # 添加税费
            final_price = self._add_local_taxes(discounted_price, user_region)
            
            return {
                'base_price': base_price,
                'discounted_price': discounted_price,
                'final_price': final_price,
                'currency': self._get_regional_currency(user_region),
                'tax_rate': self._get_tax_rate(user_region)
            }
            
        except Exception as e:
            print(f"价格计算失败: {e}")
            return None
    
    def _apply_regional_discounts(self, base_price, region, user_category):
        """应用区域性折扣"""
        discount_strategies = {
            '发展中国家': 0.3,  # 30%折扣
            '教育用户': 0.5,    # 50%折扣
            '批量采购': 0.2,    # 20%折扣
            '年度订阅': 0.15    # 15%折扣
        }
        
        discount_rate = 0
        
        # 区域性折扣
        if region in ['亚洲', '发展中国家']:
            discount_rate += discount_strategies['发展中国家']
        
        # 用户类别折扣
        if user_category == 'student':
            discount_rate += discount_strategies['教育用户']
        
        # 确保折扣率不超过70%
        discount_rate = min(discount_rate, 0.7)
        
        return base_price * (1 - discount_rate)

class AcademicWritingAssistant:
    """学术写作助手"""
    
    def __init__(self):
        self.citation_styles = [
            'APA', 'MLA', 'Chicago', 'Harvard', 'IEEE',
            'GB/T 7714', '温哥华格式'
        ]
        self.academic_templates = {
            'research_paper': '学术论文',
            'thesis': '学位论文', 
            'lab_report': '实验报告',
            'literature_review': '文献综述',
            'conference_paper': '会议论文'
        }
    
    def setup_academic_environment(self, user_discipline, institution_requirements):
        """设置学术写作环境"""
        configuration = {
            'citation_style': self._select_citation_style(
                user_discipline, institution_requirements
            ),
            'template_pack': self._get_discipline_templates(user_discipline),
            'writing_assistant': self._configure_writing_assistant(user_discipline),
            'plagiarism_check': self._setup_plagiarism_check(institution_requirements),
            'reference_manager': self._integrate_reference_manager()
        }
        
        return configuration
    
    def generate_academic_template(self, template_type, metadata):
        """生成学术模板"""
        try:
            # 选择基础模板
            base_template = self._get_base_template(template_type)
            
            # 应用机构格式要求
            formatted_template = self._apply_institution_formatting(
                base_template, metadata['institution']
            )
            
            # 插入元数据
            template_with_metadata = self._insert_metadata(
                formatted_template, metadata
            )
            
            # 设置目录结构
            structured_template = self._setup_document_structure(
                template_with_metadata, template_type
            )
            
            return structured_template
            
        except Exception as e:
            print(f"模板生成失败: {e}")
            return None
    
    def cross_language_citation_management(self, references, target_language):
        """跨语言参考文献管理"""
        processed_references = []
        
        for ref in references:
            # 统一格式处理
            standardized_ref = self._standardize_reference_format(ref)
            
            # 语言转换（如需要）
            if self._needs_language_conversion(standardized_ref, target_language):
                converted_ref = self._convert_reference_language(
                    standardized_ref, target_language
                )
                processed_references.append(converted_ref)
            else:
                processed_references.append(standardized_ref)
        
        # 按字母顺序排序
        sorted_references = self._sort_references(processed_references)
        
        return sorted_references

class EnterpriseGlobalDeployment:
    """企业全球部署管理"""
    
    def __init__(self, company_locations):
        self.company_locations = company_locations
        self.deployment_configs = {}
    
    def create_global_deployment_plan(self, company_size, security_requirements):
        """创建全球部署计划"""
        deployment_plan = {
            'network_infrastructure': self._design_global_network(),
            'data_governance': self._setup_data_governance_policy(),
            'user_management': self._design_global_user_management(),
            'compliance_framework': self._ensure_global_compliance(),
            'support_structure': self._establish_global_support()
        }
        
        # 根据公司规模调整
        if company_size > 1000:
            deployment_plan['distributed_architecture'] = (
                self._setup_distributed_architecture()
            )
        
        # 根据安全要求加强
        if security_requirements == 'high':
            deployment_plan['security_enhancements'] = (
                self._add_security_enhancements()
            )
        
        return deployment_plan
    
    def manage_cross_border_data_flow(self, data_transfer_requests):
        """管理跨境数据流"""
        compliant_transfers = []
        blocked_transfers = []
        
        for transfer_request in data_transfer_requests:
            # 检查数据敏感性
            data_sensitivity = self._assess_data_sensitivity(transfer_request['data_type'])
            
            # 验证传输合法性
            is_compliant = self._verify_transfer_compliance(
                transfer_request['from_country'],
                transfer_request['to_country'],
                data_sensitivity
            )
            
            if is_compliant:
                # 应用加密和保护措施
                secured_transfer = self._apply_data_protection_measures(transfer_request)
                compliant_transfers.append(secured_transfer)
            else:
                blocked_transfers.append({
                    'request': transfer_request,
                    'reason': '违反数据跨境传输法规'
                })
        
        return {
            'compliant_transfers': compliant_transfers,
            'blocked_transfers': blocked_transfers
        }

class GlobalPerformanceBenchmark:
    """全球性能基准测试"""
    
    def __init__(self):
        self.test_locations = [
            'North America - Virginia',
            'Europe - Frankfurt', 
            'Asia - Singapore',
            'Oceania - Sydney',
            'South America - São Paulo'
        ]
    
    def run_global_performance_test(self, test_scenarios):
        """运行全球性能测试"""
        performance_results = {}
        
        for location in self.test_locations:
            location_results = {}
            
            for scenario in test_scenarios:
                scenario_name = scenario['name']
                
                # 在目标地点运行测试
                test_result = self._run_test_at_location(scenario, location)
                
                # 分析性能指标
                performance_metrics = self._analyze_performance_metrics(test_result)
                
                location_results[scenario_name] = performance_metrics
            
            performance_results[location] = location_results
        
        # 生成比较报告
        comparative_analysis = self._generate_comparative_analysis(performance_results)
        performance_results['comparative_analysis'] = comparative_analysis
        
        return performance_results
    
    def _run_test_at_location(self, scenario, location):
        """在特定地点运行测试"""
        test_actions = {
            'document_loading': self._test_document_loading,
            'cloud_sync': self._test_cloud_synchronization,
            'realtime_collaboration': self._test_realtime_collaboration,
            'template_processing': self._test_template_processing
        }
        
        test_function = test_actions.get(scenario['type'])
        if test_function:
            return test_function(scenario['parameters'], location)
        else:
            raise ValueError(f"未知的测试场景: {scenario['type']}")

class UserExperienceResearch:
    """用户体验研究"""
    
    def __init__(self):
        self.user_segments = [
            'overseas_students',
            'international_professionals', 
            'multinational_enterprises',
            'freelance_workers'
        ]
    
    def conduct_global_ux_survey(self, survey_questions, target_segments):
        """进行全球用户体验调研"""
        survey_results = {}
        
        for segment in target_segments:
            if segment not in self.user_segments:
                continue
                
            # 收集该用户群体的反馈
            segment_feedback = self._collect_segment_feedback(segment, survey_questions)
            
            # 分析满意度指标
            satisfaction_metrics = self._analyze_satisfaction_metrics(segment_feedback)
            
            # 识别主要痛点
            pain_points = self._identify_pain_points(segment_feedback)
            
            # 收集改进建议
            improvement_suggestions = self._gather_improvement_suggestions(segment_feedback)
            
            survey_results[segment] = {
                'satisfaction_metrics': satisfaction_metrics,
                'pain_points': pain_points,
                'improvement_suggestions': improvement_suggestions,
                'sample_size': len(segment_feedback)
            }
        
        return survey_results
    
    def generate_ux_improvement_roadmap(self, survey_results):
        """生成用户体验改进路线图"""
        improvement_priorities = []
        
        for segment, results in survey_results.items():
            # 根据影响范围和严重性排序
            prioritized_issues = self._prioritize_improvement_areas(
                results['pain_points'],
                results['satisfaction_metrics']
            )
            
            for issue in prioritized_issues:
                improvement_priorities.append({
                    'user_segment': segment,
                    'issue': issue['description'],
                    'severity': issue['severity'],
                    'affected_users': issue['affected_percentage'],
                    'proposed_solution': issue['proposed_solution'],
                    'estimated_effort': issue['implementation_effort']
                })
        
        # 按严重性和影响范围排序
        sorted_priorities = sorted(
            improvement_priorities,
            key=lambda x: (x['severity'], x['affected_users']),
            reverse=True
        )
        
        return {
            'high_priority': sorted_priorities[:5],
            'medium_priority': sorted_priorities[5:10],
            'low_priority': sorted_priorities[10:]
        }