fix fgunction

constant.py → app/util/constant.py

@@ -1,411 +1,411 @@
-COUNTRY_CODES = {
-    'Afghanistan': 'af',
-    'Albania': 'al',
-    'Algeria': 'dz',
-    'Andorra': 'ad',
-    'Angola': 'ao',
-    'Antigua and Barbuda': 'ag',
-    'Argentina': 'ar',
-    'Armenia': 'am',
-    'Australia': 'au',
-    'Austria': 'at',
-    'Azerbaijan': 'az',
-    'Bahamas': 'bs',
-    'Bahrain': 'bh',
-    'Bangladesh': 'bd',
-    'Barbados': 'bb',
-    'Belarus': 'by',
-    'Belgium': 'be',
-    'Belize': 'bz',
-    'Benin': 'bj',
-    'Bhutan': 'bt',
-    'Bolivia': 'bo',
-    'Bosnia and Herzegovina': 'ba',
-    'Botswana': 'bw',
-    'Brazil': 'br',
-    'Brunei': 'bn',
-    'Bulgaria': 'bg',
-    'Burkina Faso': 'bf',
-    'Burundi': 'bi',
-    'Cambodia': 'kh',
-    'Cameroon': 'cm',
-    'Canada': 'ca',
-    'Cape Verde': 'cv',
-    'Central African Republic': 'cf',
-    'Chad': 'td',
-    'Chile': 'cl',
-    'China': 'cn',
-    'Colombia': 'co',
-    'Comoros': 'km',
-    'Congo': 'cg',
-    'Congo (Dem. Rep.)': 'cd',
-    'Costa Rica': 'cr',
-    'Cote d\'Ivoire': 'ci',
-    'Croatia': 'hr',
-    'Cuba': 'cu',
-    'Cyprus': 'cy',
-    'Czech Republic': 'cz',
-    'Denmark': 'dk',
-    'Djibouti': 'dj',
-    'Dominica': 'dm',
-    'Dominican Republic': 'do',
-    'Ecuador': 'ec',
-    'Egypt': 'eg',
-    'El Salvador': 'sv',
-    'Equatorial Guinea': 'gq',
-    'Eritrea': 'er',
-    'Estonia': 'ee',
-    'Eswatini': 'sz',
-    'Ethiopia': 'et',
-    'Fiji': 'fj',
-    'Finland': 'fi',
-    'France': 'fr',
-    'Gabon': 'ga',
-    'Gambia': 'gm',
-    'Georgia': 'ge',
-    'Germany': 'de',
-    'Ghana': 'gh',
-    'Greece': 'gr',
-    'Grenada': 'gd',
-    'Guatemala': 'gt',
-    'Guinea': 'gn',
-    'Guinea-Bissau': 'gw',
-    'Guyana': 'gy',
-    'Haiti': 'ht',
-    'Honduras': 'hn',
-    'Hong Kong': 'hk',
-    'Hungary': 'hu',
-    'Iceland': 'is',
-    'India': 'in',
-    'Indonesia': 'id',
-    'Iran': 'ir',
-    'Iraq': 'iq',
-    'Ireland': 'ie',
-    'Israel': 'il',
-    'Italy': 'it',
-    'Jamaica': 'jm',
-    'Japan': 'jp',
-    'Jordan': 'jo',
-    'Kazakhstan': 'kz',
-    'Kenya': 'ke',
-    'Kiribati': 'ki',
-    'Kosovo': 'xk',
-    'Kuwait': 'kw',
-    'Kyrgyzstan': 'kg',
-    'Laos': 'la',
-    'Latvia': 'lv',
-    'Lebanon': 'lb',
-    'Lesotho': 'ls',
-    'Liberia': 'lr',
-    'Libya': 'ly',
-    'Liechtenstein': 'li',
-    'Lithuania': 'lt',
-    'Luxembourg': 'lu',
-    'Macao': 'mo',
-    'Macedonia': 'mk',
-    'Madagascar': 'mg',
-    'Malawi': 'mw',
-    'Malaysia': 'my',
-    'Maldives': 'mv',
-    'Mali': 'ml',
-    'Malta': 'mt',
-    'Marshall Islands': 'mh',
-    'Mauritania': 'mr',
-    'Mauritius': 'mu',
-    'Mexico': 'mx',
-    'Micronesia': 'fm',
-    'Moldova': 'md',
-    'Monaco': 'mc',
-    'Mongolia': 'mn',
-    'Montenegro': 'me',
-    'Morocco': 'ma',
-    'Mozambique': 'mz',
-    'Myanmar': 'mm',
-    'Namibia': 'na',
-    'Nauru': 'nr',
-    'Nepal': 'np',
-    'Netherlands': 'nl',
-    'New Zealand': 'nz',
-    'Nicaragua': 'ni',
-    'Niger': 'ne',
-    'Nigeria': 'ng',
-    'North Korea': 'kp',
-    'North Macedonia': 'mk',
-    'Norway': 'no',
-    'Oman': 'om',
-    'Pakistan': 'pk',
-    'Palau': 'pw',
-    'Palestinian Territories': 'ps',
-    'Panama': 'pa',
-    'Papua New Guinea': 'pg',
-    'Paraguay': 'py',
-    'Peru': 'pe',
-    'Philippines': 'ph',
-    'Poland': 'pl',
-    'Portugal': 'pt',
-    'Qatar': 'qa',
-    'Romania': 'ro',
-    'Russia': 'ru',
-    'Russian Federation': 'ru',
-    'Rwanda': 'rw',
-    'Saint Kitts and Nevis': 'kn',
-    'Saint Lucia': 'lc',
-    'Saint Vincent and the Grenadines': 'vc',
-    'Samoa': 'ws',
-    'San Marino': 'sm',
-    'Sao Tome and Principe': 'st',
-    'Saudi Arabia': 'sa',
-    'Senegal': 'sn',
-    'Serbia': 'rs',
-    'Seychelles': 'sc',
-    'Sierra Leone': 'sl',
-    'Singapore': 'sg',
-    'Slovakia': 'sk',
-    'Slovenia': 'si',
-    'Solomon Islands': 'sb',
-    'Somalia': 'so',
-    'South Africa': 'za',
-    'South Korea': 'kr',
-    'South Sudan': 'ss',
-    'Spain': 'es',
-    'Sri Lanka': 'lk',
-    'St. Vincent and the Grenadines': 'vc',
-    'Sudan': 'sd',
-    'Suriname': 'sr',
-    'Swaziland': 'sz',
-    'Sweden': 'se',
-    'Switzerland': 'ch',
-    'Syria': 'sy',
-    'Taiwan': 'tw',
-    'Tajikistan': 'tj',
-    'Tanzania': 'tz',
-    'Thailand': 'th',
-    'Timor-Leste': 'tl',
-    'Togo': 'tg',
-    'Tonga': 'to',
-    'Trinidad and Tobago': 'tt',
-    'Tunisia': 'tn',
-    'Turkey': 'tr',
-    'Türkiye': 'tr',
-    'Turkmenistan': 'tm',
-    'Tuvalu': 'tv',
-    'Uganda': 'ug',
-    'Ukraine': 'ua',
-    'United Arab Emirates': 'ae',
-    'United Kingdom': 'gb',
-    'United States': 'us',
-    'United States of America': 'us',
-    'Uruguay': 'uy',
-    'Uzbekistan': 'uz',
-    'Vanuatu': 'vu',
-    'Vatican City': 'va',
-    'Venezuela': 've',
-    'Viet Nam': 'vn',
-    'Vietnam': 'vn',
-    'Yemen': 'ye',
-    'Zambia': 'zm',
-    'Zimbabwe': 'zw'
-}
-
-
-REVERSE_COUNTRY_CODES = {
-    "af": "Afghanistan",
-    "al": "Albania",
-    "dz": "Algeria",
-    "ad": "Andorra",
-    "ao": "Angola",
-    "ag": "Antigua and Barbuda",
-    "ar": "Argentina",
-    "am": "Armenia",
-    "au": "Australia",
-    "at": "Austria",
-    "az": "Azerbaijan",
-    "bs": "Bahamas",
-    "bh": "Bahrain",
-    "bd": "Bangladesh",
-    "bb": "Barbados",
-    "by": "Belarus",
-    "be": "Belgium",
-    "bz": "Belize",
-    "bj": "Benin",
-    "bt": "Bhutan",
-    "bo": "Bolivia",
-    "ba": "Bosnia and Herzegovina",
-    "bw": "Botswana",
-    "br": "Brazil",
-    "bn": "Brunei",
-    "bg": "Bulgaria",
-    "bf": "Burkina Faso",
-    "bi": "Burundi",
-    "kh": "Cambodia",
-    "cm": "Cameroon",
-    "ca": "Canada",
-    "cv": "Cape Verde",
-    "cf": "Central African Republic",
-    "td": "Chad",
-    "cl": "Chile",
-    "cn": "China",
-    "co": "Colombia",
-    "km": "Comoros",
-    "cg": "Congo",
-    "cd": "Congo (Dem. Rep.)",
-    "cr": "Costa Rica",
-    "ci": "Cote d'Ivoire",
-    "hr": "Croatia",
-    "cu": "Cuba",
-    "cy": "Cyprus",
-    "cz": "Czech Republic",
-    "dk": "Denmark",
-    "dj": "Djibouti",
-    "dm": "Dominica",
-    "do": "Dominican Republic",
-    "ec": "Ecuador",
-    "eg": "Egypt",
-    "sv": "El Salvador",
-    "gq": "Equatorial Guinea",
-    "er": "Eritrea",
-    "ee": "Estonia",
-    "sz": "Swaziland",
-    "et": "Ethiopia",
-    "fj": "Fiji",
-    "fi": "Finland",
-    "fr": "France",
-    "ga": "Gabon",
-    "gm": "Gambia",
-    "ge": "Georgia",
-    "de": "Germany",
-    "gh": "Ghana",
-    "gr": "Greece",
-    "gd": "Grenada",
-    "gt": "Guatemala",
-    "gn": "Guinea",
-    "gw": "Guinea-Bissau",
-    "gy": "Guyana",
-    "ht": "Haiti",
-    "hn": "Honduras",
-    "hk": "Hong Kong",
-    "hu": "Hungary",
-    "is": "Iceland",
-    "in": "India",
-    "id": "Indonesia",
-    "ir": "Iran",
-    "iq": "Iraq",
-    "ie": "Ireland",
-    "il": "Israel",
-    "it": "Italy",
-    "jm": "Jamaica",
-    "jp": "Japan",
-    "jo": "Jordan",
-    "kz": "Kazakhstan",
-    "ke": "Kenya",
-    "ki": "Kiribati",
-    "xk": "Kosovo",
-    "kw": "Kuwait",
-    "kg": "Kyrgyzstan",
-    "la": "Laos",
-    "lv": "Latvia",
-    "lb": "Lebanon",
-    "ls": "Lesotho",
-    "lr": "Liberia",
-    "ly": "Libya",
-    "li": "Liechtenstein",
-    "lt": "Lithuania",
-    "lu": "Luxembourg",
-    "mo": "Macao",
-    "mk": "North Macedonia",
-    "mg": "Madagascar",
-    "mw": "Malawi",
-    "my": "Malaysia",
-    "mv": "Maldives",
-    "ml": "Mali",
-    "mt": "Malta",
-    "mh": "Marshall Islands",
-    "mr": "Mauritania",
-    "mu": "Mauritius",
-    "mx": "Mexico",
-    "fm": "Micronesia",
-    "md": "Moldova",
-    "mc": "Monaco",
-    "mn": "Mongolia",
-    "me": "Montenegro",
-    "ma": "Morocco",
-    "mz": "Mozambique",
-    "mm": "Myanmar",
-    "na": "Namibia",
-    "nr": "Nauru",
-    "np": "Nepal",
-    "nl": "Netherlands",
-    "nz": "New Zealand",
-    "ni": "Nicaragua",
-    "ne": "Niger",
-    "ng": "Nigeria",
-    "kp": "North Korea",
-    "no": "Norway",
-    "om": "Oman",
-    "pk": "Pakistan",
-    "pw": "Palau",
-    "ps": "Palestinian Territories",
-    "pa": "Panama",
-    "pg": "Papua New Guinea",
-    "py": "Paraguay",
-    "pe": "Peru",
-    "ph": "Philippines",
-    "pl": "Poland",
-    "pt": "Portugal",
-    "qa": "Qatar",
-    "ro": "Romania",
-    "ru": "Russian Federation",
-    "rw": "Rwanda",
-    "kn": "Saint Kitts and Nevis",
-    "lc": "Saint Lucia",
-    "vc": "St. Vincent and the Grenadines",
-    "ws": "Samoa",
-    "sm": "San Marino",
-    "st": "Sao Tome and Principe",
-    "sa": "Saudi Arabia",
-    "sn": "Senegal",
-    "rs": "Serbia",
-    "sc": "Seychelles",
-    "sl": "Sierra Leone",
-    "sg": "Singapore",
-    "sk": "Slovakia",
-    "si": "Slovenia",
-    "sb": "Solomon Islands",
-    "so": "Somalia",
-    "za": "South Africa",
-    "kr": "South Korea",
-    "ss": "South Sudan",
-    "es": "Spain",
-    "lk": "Sri Lanka",
-    "sd": "Sudan",
-    "sr": "Suriname",
-    "se": "Sweden",
-    "ch": "Switzerland",
-    "sy": "Syria",
-    "tw": "Taiwan",
-    "tj": "Tajikistan",
-    "tz": "Tanzania",
-    "th": "Thailand",
-    "tl": "Timor-Leste",
-    "tg": "Togo",
-    "to": "Tonga",
-    "tt": "Trinidad and Tobago",
-    "tn": "Tunisia",
-    "tr": "Türkiye",
-    "tm": "Turkmenistan",
-    "tv": "Tuvalu",
-    "ug": "Uganda",
-    "ua": "Ukraine",
-    "ae": "United Arab Emirates",
-    "gb": "United Kingdom",
-    "us": "United States of America",
-    "uy": "Uruguay",
-    "uz": "Uzbekistan",
-    "vu": "Vanuatu",
-    "va": "Vatican City",
-    "ve": "Venezuela",
-    "vn": "Vietnam",
-    "ye": "Yemen",
-    "zm": "Zambia",
-    "zw": "Zimbabwe"
+COUNTRY_CODES = {
+    'Afghanistan': 'af',
+    'Albania': 'al',
+    'Algeria': 'dz',
+    'Andorra': 'ad',
+    'Angola': 'ao',
+    'Antigua and Barbuda': 'ag',
+    'Argentina': 'ar',
+    'Armenia': 'am',
+    'Australia': 'au',
+    'Austria': 'at',
+    'Azerbaijan': 'az',
+    'Bahamas': 'bs',
+    'Bahrain': 'bh',
+    'Bangladesh': 'bd',
+    'Barbados': 'bb',
+    'Belarus': 'by',
+    'Belgium': 'be',
+    'Belize': 'bz',
+    'Benin': 'bj',
+    'Bhutan': 'bt',
+    'Bolivia': 'bo',
+    'Bosnia and Herzegovina': 'ba',
+    'Botswana': 'bw',
+    'Brazil': 'br',
+    'Brunei': 'bn',
+    'Bulgaria': 'bg',
+    'Burkina Faso': 'bf',
+    'Burundi': 'bi',
+    'Cambodia': 'kh',
+    'Cameroon': 'cm',
+    'Canada': 'ca',
+    'Cape Verde': 'cv',
+    'Central African Republic': 'cf',
+    'Chad': 'td',
+    'Chile': 'cl',
+    'China': 'cn',
+    'Colombia': 'co',
+    'Comoros': 'km',
+    'Congo': 'cg',
+    'Congo (Dem. Rep.)': 'cd',
+    'Costa Rica': 'cr',
+    'Cote d\'Ivoire': 'ci',
+    'Croatia': 'hr',
+    'Cuba': 'cu',
+    'Cyprus': 'cy',
+    'Czech Republic': 'cz',
+    'Denmark': 'dk',
+    'Djibouti': 'dj',
+    'Dominica': 'dm',
+    'Dominican Republic': 'do',
+    'Ecuador': 'ec',
+    'Egypt': 'eg',
+    'El Salvador': 'sv',
+    'Equatorial Guinea': 'gq',
+    'Eritrea': 'er',
+    'Estonia': 'ee',
+    'Eswatini': 'sz',
+    'Ethiopia': 'et',
+    'Fiji': 'fj',
+    'Finland': 'fi',
+    'France': 'fr',
+    'Gabon': 'ga',
+    'Gambia': 'gm',
+    'Georgia': 'ge',
+    'Germany': 'de',
+    'Ghana': 'gh',
+    'Greece': 'gr',
+    'Grenada': 'gd',
+    'Guatemala': 'gt',
+    'Guinea': 'gn',
+    'Guinea-Bissau': 'gw',
+    'Guyana': 'gy',
+    'Haiti': 'ht',
+    'Honduras': 'hn',
+    'Hong Kong': 'hk',
+    'Hungary': 'hu',
+    'Iceland': 'is',
+    'India': 'in',
+    'Indonesia': 'id',
+    'Iran': 'ir',
+    'Iraq': 'iq',
+    'Ireland': 'ie',
+    'Israel': 'il',
+    'Italy': 'it',
+    'Jamaica': 'jm',
+    'Japan': 'jp',
+    'Jordan': 'jo',
+    'Kazakhstan': 'kz',
+    'Kenya': 'ke',
+    'Kiribati': 'ki',
+    'Kosovo': 'xk',
+    'Kuwait': 'kw',
+    'Kyrgyzstan': 'kg',
+    'Laos': 'la',
+    'Latvia': 'lv',
+    'Lebanon': 'lb',
+    'Lesotho': 'ls',
+    'Liberia': 'lr',
+    'Libya': 'ly',
+    'Liechtenstein': 'li',
+    'Lithuania': 'lt',
+    'Luxembourg': 'lu',
+    'Macao': 'mo',
+    'Macedonia': 'mk',
+    'Madagascar': 'mg',
+    'Malawi': 'mw',
+    'Malaysia': 'my',
+    'Maldives': 'mv',
+    'Mali': 'ml',
+    'Malta': 'mt',
+    'Marshall Islands': 'mh',
+    'Mauritania': 'mr',
+    'Mauritius': 'mu',
+    'Mexico': 'mx',
+    'Micronesia': 'fm',
+    'Moldova': 'md',
+    'Monaco': 'mc',
+    'Mongolia': 'mn',
+    'Montenegro': 'me',
+    'Morocco': 'ma',
+    'Mozambique': 'mz',
+    'Myanmar': 'mm',
+    'Namibia': 'na',
+    'Nauru': 'nr',
+    'Nepal': 'np',
+    'Netherlands': 'nl',
+    'New Zealand': 'nz',
+    'Nicaragua': 'ni',
+    'Niger': 'ne',
+    'Nigeria': 'ng',
+    'North Korea': 'kp',
+    'North Macedonia': 'mk',
+    'Norway': 'no',
+    'Oman': 'om',
+    'Pakistan': 'pk',
+    'Palau': 'pw',
+    'Palestinian Territories': 'ps',
+    'Panama': 'pa',
+    'Papua New Guinea': 'pg',
+    'Paraguay': 'py',
+    'Peru': 'pe',
+    'Philippines': 'ph',
+    'Poland': 'pl',
+    'Portugal': 'pt',
+    'Qatar': 'qa',
+    'Romania': 'ro',
+    'Russia': 'ru',
+    'Russian Federation': 'ru',
+    'Rwanda': 'rw',
+    'Saint Kitts and Nevis': 'kn',
+    'Saint Lucia': 'lc',
+    'Saint Vincent and the Grenadines': 'vc',
+    'Samoa': 'ws',
+    'San Marino': 'sm',
+    'Sao Tome and Principe': 'st',
+    'Saudi Arabia': 'sa',
+    'Senegal': 'sn',
+    'Serbia': 'rs',
+    'Seychelles': 'sc',
+    'Sierra Leone': 'sl',
+    'Singapore': 'sg',
+    'Slovakia': 'sk',
+    'Slovenia': 'si',
+    'Solomon Islands': 'sb',
+    'Somalia': 'so',
+    'South Africa': 'za',
+    'South Korea': 'kr',
+    'South Sudan': 'ss',
+    'Spain': 'es',
+    'Sri Lanka': 'lk',
+    'St. Vincent and the Grenadines': 'vc',
+    'Sudan': 'sd',
+    'Suriname': 'sr',
+    'Swaziland': 'sz',
+    'Sweden': 'se',
+    'Switzerland': 'ch',
+    'Syria': 'sy',
+    'Taiwan': 'tw',
+    'Tajikistan': 'tj',
+    'Tanzania': 'tz',
+    'Thailand': 'th',
+    'Timor-Leste': 'tl',
+    'Togo': 'tg',
+    'Tonga': 'to',
+    'Trinidad and Tobago': 'tt',
+    'Tunisia': 'tn',
+    'Turkey': 'tr',
+    'Türkiye': 'tr',
+    'Turkmenistan': 'tm',
+    'Tuvalu': 'tv',
+    'Uganda': 'ug',
+    'Ukraine': 'ua',
+    'United Arab Emirates': 'ae',
+    'United Kingdom': 'gb',
+    'United States': 'us',
+    'United States of America': 'us',
+    'Uruguay': 'uy',
+    'Uzbekistan': 'uz',
+    'Vanuatu': 'vu',
+    'Vatican City': 'va',
+    'Venezuela': 've',
+    'Viet Nam': 'vn',
+    'Vietnam': 'vn',
+    'Yemen': 'ye',
+    'Zambia': 'zm',
+    'Zimbabwe': 'zw'
+}
+
+
+REVERSE_COUNTRY_CODES = {
+    "af": "Afghanistan",
+    "al": "Albania",
+    "dz": "Algeria",
+    "ad": "Andorra",
+    "ao": "Angola",
+    "ag": "Antigua and Barbuda",
+    "ar": "Argentina",
+    "am": "Armenia",
+    "au": "Australia",
+    "at": "Austria",
+    "az": "Azerbaijan",
+    "bs": "Bahamas",
+    "bh": "Bahrain",
+    "bd": "Bangladesh",
+    "bb": "Barbados",
+    "by": "Belarus",
+    "be": "Belgium",
+    "bz": "Belize",
+    "bj": "Benin",
+    "bt": "Bhutan",
+    "bo": "Bolivia",
+    "ba": "Bosnia and Herzegovina",
+    "bw": "Botswana",
+    "br": "Brazil",
+    "bn": "Brunei",
+    "bg": "Bulgaria",
+    "bf": "Burkina Faso",
+    "bi": "Burundi",
+    "kh": "Cambodia",
+    "cm": "Cameroon",
+    "ca": "Canada",
+    "cv": "Cape Verde",
+    "cf": "Central African Republic",
+    "td": "Chad",
+    "cl": "Chile",
+    "cn": "China",
+    "co": "Colombia",
+    "km": "Comoros",
+    "cg": "Congo",
+    "cd": "Congo (Dem. Rep.)",
+    "cr": "Costa Rica",
+    "ci": "Cote d'Ivoire",
+    "hr": "Croatia",
+    "cu": "Cuba",
+    "cy": "Cyprus",
+    "cz": "Czech Republic",
+    "dk": "Denmark",
+    "dj": "Djibouti",
+    "dm": "Dominica",
+    "do": "Dominican Republic",
+    "ec": "Ecuador",
+    "eg": "Egypt",
+    "sv": "El Salvador",
+    "gq": "Equatorial Guinea",
+    "er": "Eritrea",
+    "ee": "Estonia",
+    "sz": "Swaziland",
+    "et": "Ethiopia",
+    "fj": "Fiji",
+    "fi": "Finland",
+    "fr": "France",
+    "ga": "Gabon",
+    "gm": "Gambia",
+    "ge": "Georgia",
+    "de": "Germany",
+    "gh": "Ghana",
+    "gr": "Greece",
+    "gd": "Grenada",
+    "gt": "Guatemala",
+    "gn": "Guinea",
+    "gw": "Guinea-Bissau",
+    "gy": "Guyana",
+    "ht": "Haiti",
+    "hn": "Honduras",
+    "hk": "Hong Kong",
+    "hu": "Hungary",
+    "is": "Iceland",
+    "in": "India",
+    "id": "Indonesia",
+    "ir": "Iran",
+    "iq": "Iraq",
+    "ie": "Ireland",
+    "il": "Israel",
+    "it": "Italy",
+    "jm": "Jamaica",
+    "jp": "Japan",
+    "jo": "Jordan",
+    "kz": "Kazakhstan",
+    "ke": "Kenya",
+    "ki": "Kiribati",
+    "xk": "Kosovo",
+    "kw": "Kuwait",
+    "kg": "Kyrgyzstan",
+    "la": "Laos",
+    "lv": "Latvia",
+    "lb": "Lebanon",
+    "ls": "Lesotho",
+    "lr": "Liberia",
+    "ly": "Libya",
+    "li": "Liechtenstein",
+    "lt": "Lithuania",
+    "lu": "Luxembourg",
+    "mo": "Macao",
+    "mk": "North Macedonia",
+    "mg": "Madagascar",
+    "mw": "Malawi",
+    "my": "Malaysia",
+    "mv": "Maldives",
+    "ml": "Mali",
+    "mt": "Malta",
+    "mh": "Marshall Islands",
+    "mr": "Mauritania",
+    "mu": "Mauritius",
+    "mx": "Mexico",
+    "fm": "Micronesia",
+    "md": "Moldova",
+    "mc": "Monaco",
+    "mn": "Mongolia",
+    "me": "Montenegro",
+    "ma": "Morocco",
+    "mz": "Mozambique",
+    "mm": "Myanmar",
+    "na": "Namibia",
+    "nr": "Nauru",
+    "np": "Nepal",
+    "nl": "Netherlands",
+    "nz": "New Zealand",
+    "ni": "Nicaragua",
+    "ne": "Niger",
+    "ng": "Nigeria",
+    "kp": "North Korea",
+    "no": "Norway",
+    "om": "Oman",
+    "pk": "Pakistan",
+    "pw": "Palau",
+    "ps": "Palestinian Territories",
+    "pa": "Panama",
+    "pg": "Papua New Guinea",
+    "py": "Paraguay",
+    "pe": "Peru",
+    "ph": "Philippines",
+    "pl": "Poland",
+    "pt": "Portugal",
+    "qa": "Qatar",
+    "ro": "Romania",
+    "ru": "Russian Federation",
+    "rw": "Rwanda",
+    "kn": "Saint Kitts and Nevis",
+    "lc": "Saint Lucia",
+    "vc": "St. Vincent and the Grenadines",
+    "ws": "Samoa",
+    "sm": "San Marino",
+    "st": "Sao Tome and Principe",
+    "sa": "Saudi Arabia",
+    "sn": "Senegal",
+    "rs": "Serbia",
+    "sc": "Seychelles",
+    "sl": "Sierra Leone",
+    "sg": "Singapore",
+    "sk": "Slovakia",
+    "si": "Slovenia",
+    "sb": "Solomon Islands",
+    "so": "Somalia",
+    "za": "South Africa",
+    "kr": "South Korea",
+    "ss": "South Sudan",
+    "es": "Spain",
+    "lk": "Sri Lanka",
+    "sd": "Sudan",
+    "sr": "Suriname",
+    "se": "Sweden",
+    "ch": "Switzerland",
+    "sy": "Syria",
+    "tw": "Taiwan",
+    "tj": "Tajikistan",
+    "tz": "Tanzania",
+    "th": "Thailand",
+    "tl": "Timor-Leste",
+    "tg": "Togo",
+    "to": "Tonga",
+    "tt": "Trinidad and Tobago",
+    "tn": "Tunisia",
+    "tr": "Türkiye",
+    "tm": "Turkmenistan",
+    "tv": "Tuvalu",
+    "ug": "Uganda",
+    "ua": "Ukraine",
+    "ae": "United Arab Emirates",
+    "gb": "United Kingdom",
+    "us": "United States of America",
+    "uy": "Uruguay",
+    "uz": "Uzbekistan",
+    "vu": "Vanuatu",
+    "va": "Vatican City",
+    "ve": "Venezuela",
+    "vn": "Vietnam",
+    "ye": "Yemen",
+    "zm": "Zambia",
+    "zw": "Zimbabwe"
 }

app/util/visa_availability_scraper_playwright.py

@@ -1,8 +1,11 @@
 import asyncio
-import pandas as pd
+import json
 from typing import Dict, Optional, List
-from constant import COUNTRY_CODES, REVERSE_COUNTRY_CODES
 from playwright.async_api import async_playwright
+from playwright_stealth import Stealth
+from constant import COUNTRY_CODES, REVERSE_COUNTRY_CODES
+import pandas as pd
+import random
 
 class PassportIndexVisaScraper:
     def __init__(self, debug: bool = True):
@@ -18,55 +21,102 @@ class PassportIndexVisaScraper:
         self.browser = None
         self.context = None
         self.page = None
+        self.playwright = None
+        self.stealth_manager = None
         
     async def __aenter__(self):
         """Initialize browser with stealth mode"""
-        self.playwright = await async_playwright().start()
+        # Initialize Playwright with Stealth using context manager pattern
+        self.stealth_manager = Stealth().use_async(async_playwright())
+        self.playwright = await self.stealth_manager.__aenter__()
+
+        # Random viewport for more natural appearance
+        viewport_width = random.randint(1366, 1920)
+        viewport_height = random.randint(768, 1080)
         
+        # Launch browser in headless mode with stealth settings
         self.browser = await self.playwright.chromium.launch(
-            headless=False,  # Using headless mode
+            headless=False,  
             args=[
                 '--disable-blink-features=AutomationControlled',
                 '--disable-dev-shm-usage',
                 '--no-sandbox',
                 '--disable-setuid-sandbox',
+                f'--window-size={viewport_width},{viewport_height}',
+                '--disable-features=IsolateOrigins,site-per-process',
+                '--enable-features=NetworkService,NetworkServiceInProcess',
+                '--disable-infobars',
+                '--hide-scrollbars',
+                '--mute-audio',
+                '--disable-background-timer-throttling',
+                '--disable-renderer-backgrounding',
+                '--disable-features=TranslateUI',
+                '--disable-ipc-flooding-protection',
+                '--force-color-profile=srgb',
+                '--metrics-recording-only',
+                '--disable-hang-monitor',
+                '--disable-popup-blocking',
+                '--disable-prompt-on-repost',
+                '--disable-background-networking',
+                '--disable-breakpad',
+                '--disable-client-side-phishing-detection',
+                '--disable-component-extensions-with-background-pages',
+                '--disable-default-apps',
+                '--disable-extensions',
+                '--disable-features=TranslateUI,BlinkGenPropertyTrees',
+                '--disable-sync',
                 '--disable-web-security',
-                '--disable-features=IsolateOrigins,site-per-process'
+                '--disable-site-isolation-trials',
+                '--no-first-run',
+                '--no-default-browser-check',
+                '--no-pings'
             ]
         )
+
+        # Rotate user agents
+        user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        ]
         
         # Create context with realistic settings
         self.context = await self.browser.new_context(
-            viewport={'width': 1920, 'height': 1080},
-            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
+            viewport={'width': viewport_width, 'height': viewport_height},
+            user_agent=random.choice(user_agents),
             locale='en-US',
-            timezone_id='America/New_York'
+            timezone_id='America/New_York',
+            accept_downloads=False,
+            has_touch=False,
+            is_mobile=False,
+            device_scale_factor=1,
+            bypass_csp=True,
+            ignore_https_errors=True,
+            java_script_enabled=True
         )
         
         self.page = await self.context.new_page()
 
+        # Add additional stealth measures
         await self.page.add_init_script("""
-            // Override the navigator.webdriver property
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined
-            });
-
-            // Override chrome property
-            window.chrome = {
-                runtime: {}
-            };
-
-            // Override permissions
-            const originalQuery = window.navigator.permissions.query;
-            window.navigator.permissions.query = (parameters) => (
-                parameters.name === 'notifications' ?
-                    Promise.resolve({ state: Notification.permission }) :
-                    originalQuery(parameters)
-            );
+            // Additional evasion beyond what stealth plugin provides
+            delete Object.getPrototypeOf(navigator).webdriver;
+            
+            // Add some randomness to make fingerprint unique
+            const battery = navigator.getBattery;
+            if (battery) {
+                navigator.getBattery = async () => ({
+                    charging: Math.random() > 0.5,
+                    chargingTime: Math.floor(Math.random() * 10000),
+                    dischargingTime: Math.floor(Math.random() * 10000),
+                    level: Math.random()
+                });
+            }
         """)
         
         if self.debug:
-            print("🚀 Browser initialized with stealth mode")
+            print("🚀 Browser initialized with stealth mode (headless)")
         
         return self
     
@@ -78,8 +128,8 @@ class PassportIndexVisaScraper:
             await self.context.close()
         if self.browser:
             await self.browser.close()
-        if self.playwright:
-            await self.playwright.stop()
+        if hasattr(self, 'stealth_manager') and self.stealth_manager:
+            await self.stealth_manager.__aexit__(exc_type, exc_val, exc_tb)
         
         if self.debug:
             print("🔒 Browser closed")
@@ -88,44 +138,147 @@ class PassportIndexVisaScraper:
         """
         Navigate to the website and wait for it to load properly
         """
-        try:
-            if self.debug:
-                print("📱 Initializing session...")
-            
-            # Navigate to the page
+        max_retries = 3
+        for attempt in range(max_retries):
             try:
+                if self.debug:
+                    print(f"📱 Initializing session... (Attempt {attempt + 1}/{max_retries})")
+
+                # Add random delay to appear more human
+                if attempt > 0:
+                    await self.page.wait_for_timeout(random.randint(2000, 5000))
+                
+                # Navigate to the page with proper wait
                 response = await self.page.goto(
                     self.base_url,
-                    wait_until='domcontentloaded',
-                    timeout=30000
+                    wait_until='networkidle',
+                    timeout=60000
                 )
-                await self.page.wait_for_timeout(3000)
+
+                # Check for Cloudflare challenge
+                page_content = await self.page.content()
+                if "Just a moment" in page_content or "cf-challenge" in page_content:
+                    if self.debug:
+                        print("⏳ Cloudflare challenge detected, waiting...")
+
+                    # Wait for Cloudflare to complete
+                    await self.page.wait_for_timeout(15000)
+
+                    # Try to wait for actual content
+                    try:
+                        await self.page.wait_for_selector('.vch-table', state='visible', timeout=20000)
+                    except:
+                        if attempt < max_retries - 1:
+                            continue
+                        else:
+                            if self.debug:
+                                print("⚠️ Cloudflare challenge persists")
+                        # Try to reload the page
+                        await self.page.reload(wait_until='networkidle', timeout=60000)
+                        await self.page.wait_for_timeout(5000)
+                
+                
+                # Wait for page to be ready - try multiple selectors
+                try:
+                    # Try to wait for any of these elements that indicate page is loaded
+                    await self.page.wait_for_selector('.vch-table', state='visible', timeout=15000)
+                except:
+                    # If wait fails, just continue after a delay
+                    if self.debug:
+                        print("⚠️ Could not find expected elements, continuing anyway...")
+                    await self.page.wait_for_timeout(3000)
+                
+                # Close/hide the virtual keyboard if it exists
+                await self.close_virtual_keyboard()
                 
-                # Get the cl value from the page
+                # Get the session value from the page
                 cl_value = await self.page.evaluate("""
                     () => {
                         const clInput = document.querySelector('#cl');
-                        return clInput ? clInput.value : 'bc2140a2d83928ce1112d01e610bad89';
+                        // Also check if the page has the visa checker elements
+                        const hasVchTable = document.querySelector('.vch-table') !== null;
+                        const hasPassSelect = document.querySelector('.vch-select-pass') !== null;
+
+                        return {
+                            cl: clInput ? clInput.value : null,
+                            hasTable: hasVchTable,
+                            hasSelectors: hasPassSelect,
+                            url: window.location.href
+                        };
                     }
                 """)
                 
                 if self.debug:
-                    print(f"✅ Page loaded, session ID: {cl_value}")
-                    
+                    if cl_value and cl_value.get('cl'):
+                        print(f"✅ Page loaded, session ID: {cl_value['cl']}")
+                        print(f"   Table present: {cl_value['hasTable']}, Selectors present: {cl_value['hasSelectors']}")
+                        print(f"   URL: {cl_value['url']}")
+                    else:
+                        print(f"⚠️ Page loaded but missing elements: {cl_value}")
+                        # If elements are missing, try one more time with a longer wait
+                        if not cl_value.get('hasTable'):
+                            await self.page.wait_for_timeout(10000)
+                            cl_value = await self.page.evaluate("""
+                                () => {
+                                    const clInput = document.querySelector('#cl');
+                                    const hasVchTable = document.querySelector('.vch-table') !== null;
+                                    const hasPassSelect = document.querySelector('.vch-select-pass') !== null;
+                                    return {
+                                        cl: clInput ? clInput.value : null,
+                                        hasTable: hasVchTable,
+                                        hasSelectors: hasPassSelect,
+                                        url: window.location.href
+                                    };
+                                }
+                            """)
+                            if cl_value.get('hasTable'):
+                                print(f"✅ Elements loaded after additional wait")
+                            else:
+                                # Continue anyway, might still work
+                                pass
+                        
                 return True
-                
+                    
             except Exception as e:
-                if self.debug:
-                    print(f"⚠️ Page load issue: {e}, continuing anyway...")
-                return True
+                if attempt == max_retries - 1:
+                    print(f"❌ Error initializing session after {max_retries} attempts: {e}")
+                    return False
+                else:
+                    if self.debug:
+                        print(f"⚠️ Attempt {attempt + 1} failed: {e}")
+                    continue
+        return False
+    
+    async def close_virtual_keyboard(self):
+        """Close the virtual keyboard if it's open"""
+        try:
+            # Check if virtual keyboard exists and is visible
+            keyboard_visible = await self.page.evaluate("""
+                () => {
+                    const keyboard = document.querySelector('#PI-VirtualKeyboard');
+                    if (keyboard) {
+                        // Hide the keyboard
+                        keyboard.style.display = 'none';
+                        keyboard.classList.remove('kioskboard-opened');
+                        // Also hide any overlay elements
+                        const overlays = document.querySelectorAll('.kioskboard-wrapper, .kioskboard-overlay');
+                        overlays.forEach(el => el.style.display = 'none');
+                        return true;
+                    }
+                    return false;
+                }
+            """)
+            
+            if keyboard_visible and self.debug:
+                print("⌨️ Virtual keyboard hidden")
                 
         except Exception as e:
-            print(f"❌ Error initializing session: {e}")
-            return False
+            if self.debug:
+                print(f"⚠️ Could not hide virtual keyboard: {e}")
     
-    async def check_visa_requirement_browser(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+    async def check_visa_requirement_api(self, passport_country: str, destination_country: str) -> Optional[Dict]:
         """
-        Check visa requirements using browser automation
+        Check visa requirements using direct API call with cookies
         
         Args:
             passport_country: Two-letter country code for passport
@@ -136,9 +289,12 @@ class PassportIndexVisaScraper:
         """
         try:
             if self.debug:
-                print(f"🌐 Checking {passport_country.upper()} → {destination_country.upper()}")
+                print(f"🌐 Checking {passport_country.upper()} → {destination_country.upper()} via API")
             
-            # Get the current session ID from the page
+            # Get cookies from the page
+            cookies = await self.context.cookies()
+            
+            # Get the session ID
             cl_value = await self.page.evaluate("""
                 () => {
                     const clInput = document.querySelector('#cl');
@@ -146,13 +302,15 @@ class PassportIndexVisaScraper:
                 }
             """)
             
-            # Make the API request through the browser with proper argument passing
+            # Make the API request with proper cookies and headers
             result = await self.page.evaluate("""
                 async (args) => {
                     const [passport, destination, sessionId] = args;
+                    
+                    // Create form data
                     const formData = new URLSearchParams();
-                    formData.append('d', destination);
-                    formData.append('s', passport);
+                    formData.append('d', destination.toLowerCase());
+                    formData.append('s', passport.toLowerCase());
                     formData.append('cl', sessionId);
                     
                     try {
@@ -161,130 +319,254 @@ class PassportIndexVisaScraper:
                             headers: {
                                 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                                 'X-Requested-With': 'XMLHttpRequest',
-                                'Accept': 'application/json, text/javascript, */*; q=0.01'
+                                'Accept': 'application/json, text/javascript, */*; q=0.01',
+                                'Origin': 'https://www.passportindex.org',
+                                'Referer': 'https://www.passportindex.org/travel-visa-checker/'
                             },
                             body: formData.toString(),
-                            credentials: 'include'
+                            credentials: 'include',
+                            mode: 'cors'
                         });
                         
-                        if (!response.ok) {
-                            throw new Error(`HTTP ${response.status}`);
-                        }
+                        const responseText = await response.text();
                         
-                        const data = await response.json();
-                        return data;
+                        // Try to parse as JSON
+                        try {
+                            return JSON.parse(responseText);
+                        } catch {
+                            // Check if it's a Cloudflare challenge
+                            if (responseText.includes("Just a moment") || 
+                                responseText.includes("cf-challenge") || 
+                                response.status === 403) {
+                                return { error: 'Cloudflare block', status: response.status };
+                            }
+                            // Otherwise it might be a different error
+                            return { error: 'Invalid response', status: response.status };
+                        }
                     } catch (error) {
                         return { error: error.message };
                     }
                 }
-            """, [passport_country.lower(), destination_country.lower(), cl_value])
+            """, [passport_country, destination_country, cl_value])
             
-            if result and 'error' not in result:
+            if result and 'error' not in result and 'text' in result:
                 if self.debug:
-                    print(f"✅ Got result: {result}")
+                    print(f"✅ Got API result: {json.dumps(result)}")
                 return result
             elif result and 'error' in result:
-                print(result)
-                print(f"❌ API Error: {result['error']}")
+                if self.debug:
+                    print(f"⚠️ API Error: {result['error']}")
                 return None
             else:
                 return None
                 
         except Exception as e:
-            print(f"❌ Error checking visa requirement: {e}")
+            if self.debug:
+                print(f"❌ Error checking visa requirement via API: {e}")
             return None
     
-    async def check_visa_interactive(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+    async def check_visa_interactive_v2(self, passport_country: str, destination_country: str) -> Optional[Dict]:
         """
-        Alternative method: Use the interactive UI to check visa requirements
+        Alternative interactive method with better element handling
         """
         try:
             if self.debug:
-                print(f"🖱️ Using interactive method for {passport_country.upper()} → {destination_country.upper()}")
+                print(f"🖱️ Using interactive method v2 for {passport_country.upper()} → {destination_country.upper()}")
             
-            # Click on the passport selector
-            await self.page.click('.vch-select-pass')
-            await self.page.wait_for_timeout(500)
+            # First, ensure virtual keyboard is hidden
+            await self.close_virtual_keyboard()
             
-            # Find and click the country in the list
-            passport_selector = f'.vch-passports .s-div[data-ccode="{passport_country.lower()}"]'
-            await self.page.wait_for_selector(passport_selector, timeout=3000)
-            await self.page.click(passport_selector)
-            await self.page.wait_for_timeout(500)
+            # Clear any previous selections via JavaScript
+            await self.page.evaluate("""
+                () => {
+                    // Reset the form
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    const destSelect = document.querySelector('.vch-select-des');
+                    if (passSelect) passSelect.textContent = 'Select Passport';
+                    if (destSelect) destSelect.textContent = 'Select Destination';
+                    
+                    // Hide any open dropdowns
+                    const passports = document.querySelector('.vch-passports');
+                    const destinations = document.querySelector('.vch-destinations');
+                    if (passports) passports.classList.remove('opener');
+                    if (destinations) destinations.classList.remove('opener');
+                }
+            """)
             
-            # Click on the destination selector
-            await self.page.click('.vch-select-des')
             await self.page.wait_for_timeout(500)
             
-            # Find and click the destination country
-            dest_selector = f'.vch-destinations .s-div[data-ccode="{destination_country.lower()}"]'
-            await self.page.wait_for_selector(dest_selector, timeout=5000)
-            await self.page.click(dest_selector)
+            # Select passport using JavaScript
+            passport_selected = await self.page.evaluate("""
+                (countryCode) => {
+                    // Click the passport selector
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    if (!passSelect) return false;
+                    passSelect.click();
+                    
+                    // Wait a bit for dropdown to open
+                    setTimeout(() => {
+                        // Find and click the country
+                        const countryElement = document.querySelector(`.vch-passports .s-div[data-ccode="${countryCode.toLowerCase()}"]`);
+                        if (countryElement) {
+                            countryElement.click();
+                            return true;
+                        }
+                    }, 300);
+                    
+                    return false;
+                }
+            """, passport_country)
+            
             await self.page.wait_for_timeout(1000)
             
-            # Get the result from the page
+            # Select destination using JavaScript
+            destination_selected = await self.page.evaluate("""
+                (countryCode) => {
+                    // Click the destination selector
+                    const destSelect = document.querySelector('.vch-select-des');
+                    if (!destSelect) return false;
+                    destSelect.click();
+                    
+                    // Wait a bit for dropdown to open
+                    setTimeout(() => {
+                        // Find and click the country
+                        const countryElement = document.querySelector(`.vch-destinations .s-div[data-ccode="${countryCode.toLowerCase()}"]`);
+                        if (countryElement) {
+                            countryElement.click();
+                            return true;
+                        }
+                    }, 300);
+                    
+                    return false;
+                }
+            """, destination_country)
+            
+            await self.page.wait_for_timeout(2000)
+            
+            # Get the result
             result = await self.page.evaluate("""
                 () => {
                     const resultElement = document.querySelector('.vch-result');
                     if (resultElement) {
                         const text = resultElement.querySelector('.text');
                         const days = resultElement.querySelector('.days');
+                        const passSelect = document.querySelector('.vch-select-pass');
+                        const destSelect = document.querySelector('.vch-select-des');
+                        
                         return {
-                            text: text ? text.textContent : '',
-                            days: days ? days.textContent : '',
-                            pass: '""" + passport_country.lower() + """',
-                            dest: '""" + destination_country.upper() + """'
+                            text: text ? text.textContent.trim() : '',
+                            days: days ? days.textContent.trim() : '',
+                            pass: passSelect ? passSelect.textContent.trim() : '',
+                            dest: destSelect ? destSelect.textContent.trim() : ''
                         };
                     }
                     return null;
                 }
             """)
             
-            return result
+            if result and result['text']:
+                return result
+            
+            return None
             
         except Exception as e:
             if self.debug:
-                print(f"❌ Interactive method failed: {e}")
+                print(f"❌ Interactive method v2 failed: {e}")
             return None
-    async def check_multiple_source(self, passport_countries: List[str], destination: str, delay: float = 2.0) -> Dict:
+    
+    async def check_visa_direct_manipulation(self, passport_country: str, destination_country: str) -> Optional[Dict]:
         """
-        Check visa requirements for multiple passport countries to a single destination.
-        
-        Args:
-            passport_countries: List of two-letter country codes for passports.
-            destination: Two-letter country code for the destination.
-            delay: Delay between requests in seconds.
-            
-        Returns:
-            Dictionary mapping passport country codes to visa information.
+        Direct manipulation method - directly trigger the visa check
         """
-        results = {}
-        
-        for i, passport in enumerate(passport_countries, 1):
-            print(f"\n[{i}/{len(passport_countries)}] Checking {passport.upper()} → {destination.upper()}...")
-            
-            # Try API method first
-            result = await self.check_visa_requirement_browser(passport, destination)
+        try:
+            if self.debug:
+                print(f"🔧 Using direct manipulation for {passport_country.upper()} → {destination_country.upper()}")
             
-            # If API fails, try interactive method
-            if not result:
-                result = await self.check_visa_interactive(passport, destination)
+            # Directly call the visa checker function if it exists
+            result = await self.page.evaluate("""
+                async (args) => {
+                    const [passport, destination] = args;
+                    // Try to find and call the visa checker function directly
+                    if (typeof visaChecker !== 'undefined' && typeof visaChecker.check === 'function') {
+                        return await visaChecker.check(passport, destination);
+                    }
+                    
+                    // Alternative: manually trigger the check
+                    const cl = document.querySelector('#cl')?.value || 'bc2140a2d83928ce1112d01e610bad89';
+                    
+                    // Set the selections visually
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    const destSelect = document.querySelector('.vch-select-des');
+                    
+                    if (passSelect && destSelect) {
+                        // Find country names
+                        const passportElement = document.querySelector(`.vch-passports .s-div[data-ccode="${passport}"] .cname`);
+                        const destElement = document.querySelector(`.vch-destinations .s-div[data-ccode="${destination}"] .cname`);
+                        
+                        if (passportElement) passSelect.textContent = passportElement.textContent;
+                        if (destElement) destSelect.textContent = destElement.textContent;
+                        
+                        // Make the AJAX call
+                        return new Promise((resolve) => {
+                            $.ajax({
+                                url: 'https://www.passportindex.org/core/visachecker.php',
+                                type: 'POST',
+                                data: {
+                                    d: destination,
+                                    s: passport,
+                                    cl: cl
+                                },
+                                success: function(response) {
+                                    // Update the UI
+                                    if (response.text) {
+                                        const resultElement = document.querySelector('.vch-result');
+                                        if (resultElement) {
+                                            resultElement.className = 'vch-result tv-grey ' + (response.vr ? 'tvvr' : 'tvvf');
+                                            const textElement = resultElement.querySelector('.text');
+                                            if (textElement) textElement.textContent = response.text;
+                                        }
+                                    }
+                                    resolve(response);
+                                },
+                                error: function(xhr) {
+                                    resolve({ error: 'Request failed', status: xhr.status });
+                                }
+                            });
+                        });
+                    }
+                    
+                    return null;
+                }
+            """, [passport_country.lower(), destination_country.lower()])
             
-            if result:
-                results[passport] = result
-                text = result.get('text', 'No text available')
-                print(f"  ✅ Result: {text}")
-            else:
-                results[passport] = None
-                print(f"  ❌ Failed to get result")
+            return result
             
-            # Rate limiting to avoid blocking
-            if i < len(passport_countries):
-                print(f"  ⏳ Waiting {delay} seconds...")
-                await asyncio.sleep(delay)
+        except Exception as e:
+            if self.debug:
+                print(f"❌ Direct manipulation failed: {e}")
+            return None
+    
+    async def check_visa_requirement(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+        """
+        Main method to check visa requirements - tries multiple approaches
+        """
+        # Try API method first
+        result = await self.check_visa_requirement_api(passport_country, destination_country)
+        if result:
+            return result
         
-        return results
-
+        # Try direct manipulation
+        result = await self.check_visa_direct_manipulation(passport_country, destination_country)
+        if result:
+            return result
+        
+        # Try interactive method v2
+        result = await self.check_visa_interactive_v2(passport_country, destination_country)
+        if result:
+            return result
+        
+        return None
+    
     async def check_multiple_destinations(self, passport_country: str, destinations: List[str], delay: float = 2.0) -> Dict:
         """
         Check visa requirements for multiple destinations
@@ -302,12 +584,7 @@ class PassportIndexVisaScraper:
         for i, dest in enumerate(destinations, 1):
             print(f"\n[{i}/{len(destinations)}] Checking {passport_country.upper()} → {dest.upper()}...")
             
-            # Try API method first
-            result = await self.check_visa_requirement_browser(passport_country, dest)
-            
-            # If API fails, try interactive method
-            if not result:
-                result = await self.check_visa_interactive(passport_country, dest)
+            result = await self.check_visa_requirement(passport_country, dest)
             
             if result:
                 results[dest] = result
@@ -329,14 +606,57 @@ class PassportIndexVisaScraper:
         if not result:
             return "No information available"
         
-        text = result.get('text', 'N/A')
-        dest = result.get('dest', 'N/A')
-        passport = result.get('pass', 'N/A')
-        
-        return f"{passport.upper()} → {dest.upper()}: {text}"
+        # Return clean JSON format
+        return json.dumps({
+            'text': result.get('text', 'N/A'),
+            'col': result.get('col', ''),
+            'link': result.get('link', 0),
+            'dest': result.get('dest', '').upper(),
+            'pass': result.get('pass', '').upper()
+        })
 
 
 async def main():
+    """Main function to demonstrate usage"""
+    print("="*60)
+    print(" Passport Index Visa Checker (Playwright - Fixed)")
+    print("="*60)
+    
+    async with PassportIndexVisaScraper(debug=True) as scraper:
+        # Initialize session
+        if not await scraper.initialize_session():
+            print("❌ Failed to initialize session")
+            return
+        
+        print("\n" + "="*60)
+        print(" Testing visa requirements...")
+        print("="*60)
+        
+        # Test single visa requirement
+        print("\n📍 Single visa check: US → GB")
+        print("-" * 40)
+        result = await scraper.check_visa_requirement('us', 'gb')
+        if result:
+            print(f"Result: {json.dumps(result)}")
+        else:
+            print("❌ Failed to get result")
+        
+        # Test multiple destinations
+        print("\n📍 Multiple destinations for US passport:")
+        print("-" * 40)
+        destinations = ['ca', 'mx', 'jp', 'au']  # Canada, Mexico, Japan, Australia
+        results = await scraper.check_multiple_destinations('us', destinations, delay=2.0)
+        
+        print("\n📊 Summary:")
+        for dest, result in results.items():
+            if result:
+                print(f"  ✅ {dest.upper()}: {json.dumps(result)}")
+            else:
+                print(f"  ❌ US → {dest.upper()}: Failed")
+
+
+
+async def indo():
     print("="*60)
     print(" Passport Index Visa Checker (Playwright)")
     print("="*60)