PyPI - veil-cli - Versions diffs - 0.1.0__tar.gz - Mend

veil-cli 0.1.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

veil_cli-0.1.0/PKG-INFO +8 -0
veil_cli-0.1.0/app/__init__.py +1 -0
veil_cli-0.1.0/app/__main__.py +4 -0
veil_cli-0.1.0/app/cli.py +121 -0
veil_cli-0.1.0/app/country_table.py +527 -0
veil_cli-0.1.0/app/netinfo.py +109 -0
veil_cli-0.1.0/app/ooni.py +158 -0
veil_cli-0.1.0/app/ui.py +267 -0
veil_cli-0.1.0/pyproject.toml +20 -0
veil_cli-0.1.0/setup.cfg +4 -0
veil_cli-0.1.0/veil_cli.egg-info/PKG-INFO +8 -0
veil_cli-0.1.0/veil_cli.egg-info/SOURCES.txt +14 -0
veil_cli-0.1.0/veil_cli.egg-info/dependency_links.txt +1 -0
veil_cli-0.1.0/veil_cli.egg-info/entry_points.txt +2 -0
veil_cli-0.1.0/veil_cli.egg-info/requires.txt +2 -0
veil_cli-0.1.0/veil_cli.egg-info/top_level.txt +1 -0

veil_cli-0.1.0/PKG-INFO ADDED Viewed

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: veil-cli
+Version: 0.1.0
+Summary: Check whether a site is blocked in a given country, using OONI data.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13.0

veil_cli-0.1.0/app/__init__.py ADDED Viewed

	@@ -0,0 +1 @@
1	+ __version__ = "0.1.0"

veil_cli-0.1.0/app/__main__.py ADDED Viewed

@@ -0,0 +1,4 @@
+from app.cli import main
+if __name__ == "__main__":
+    main()

veil_cli-0.1.0/app/cli.py ADDED Viewed

@@ -0,0 +1,121 @@
+from __future__ import annotations
+import argparse
+import sys
+from app import ui
+from app.country_table import CANONICAL_NAMES, COUNTRY_CODES
+from app.netinfo import gather_site_details
+from app.ooni import OoniError, aggregate_by_country, aggregate_for_country
+def resolve_country(raw: str) -> tuple[str, str] | None:
+    raw = raw.strip()
+    if not raw:
+        return None
+    if len(raw) == 2 and raw.upper() in CANONICAL_NAMES:
+        code = raw.upper()
+        return code, CANONICAL_NAMES[code]
+    for name, code in COUNTRY_CODES.items():
+        if name.lower() == raw.lower():
+            return code, CANONICAL_NAMES.get(code, name)
+    for name, code in COUNTRY_CODES.items():
+        if raw.lower() in name.lower():
+            return code, CANONICAL_NAMES.get(code, name)
+    return None
+def run_scan(domain: str, country_raw: str | None) -> None:
+    with ui.spinner(f"looking up {domain}..."):
+        details = gather_site_details(domain)
+    ui.render_site_details(details)
+    if details.resolve_error:
+        return
+    if country_raw:
+        resolved = resolve_country(country_raw)
+        if not resolved:
+            ui.error_line(
+                f"couldn't recognize country '{country_raw}' — try a 2-letter "
+                f"code like IR, or a full name like Iran."
+            )
+            return
+        code, name = resolved
+        try:
+            with ui.spinner(f"querying OONI for {domain} in {name} (can take up to a minute)..."):
+                verdict = aggregate_for_country(details.domain, code)
+        except OoniError as exc:
+            ui.error_line(str(exc))
+            return
+        ui.render_country_verdict(verdict, name)
+    else:
+        try:
+            with ui.spinner(f"querying OONI across all countries for {domain} (can take up to a minute)..."):
+                verdicts, days_used = aggregate_by_country(details.domain)
+        except OoniError as exc:
+            ui.error_line(str(exc))
+            return
+        ui.render_country_list(verdicts, details.domain, days_used)
+def interactive_loop() -> None:
+    ui.clear_screen()
+    ui.print_banner()
+    ui.print_intro_box()
+    while True:
+        try:
+            site = ui.prompt_site()
+        except (KeyboardInterrupt, EOFError):
+            ui.console.print()
+            break
+        if not site:
+            continue
+        if site.lower() in ("exit", "quit", "q"):
+            break
+        if site.lower() in ("help", "?"):
+            ui.print_help()
+            continue
+        try:
+            country = ui.prompt_country()
+        except (KeyboardInterrupt, EOFError):
+            ui.console.print()
+            break
+        ui.console.print()
+        run_scan(site, country or None)
+        ui.console.print()
+    ui.status_line("goodbye.")
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="veil",
+        description="Check whether a site is blocked in a given country, using OONI data.",
+    )
+    parser.add_argument("site", nargs="?", help="domain to check, e.g. youtube.com")
+    parser.add_argument("--country", "-c", help="country code or name, e.g. IR or Iran")
+    parser.add_argument(
+        "--list", "-l", action="store_true",
+        help="list all countries with blocking signal for this site (ignores --country)",
+    )
+    return parser
+def main() -> None:
+    parser = build_parser()
+    args = parser.parse_args()
+    if not args.site:
+        interactive_loop()
+        return
+    ui.print_banner()
+    country = None if args.list else args.country
+    run_scan(args.site, country)
+if __name__ == "__main__":
+    main()

veil_cli-0.1.0/app/country_table.py ADDED Viewed

@@ -0,0 +1,527 @@
+COUNTRY_CODES = {
+    "Afghanistan": "AF",
+    "Albania": "AL",
+    "Algeria": "DZ",
+    "America": "US",
+    "American Samoa": "AS",
+    "Andorra": "AD",
+    "Angola": "AO",
+    "Anguilla": "AI",
+    "Antarctica": "AQ",
+    "Antigua and Barbuda": "AG",
+    "Argentina": "AR",
+    "Armenia": "AM",
+    "Aruba": "AW",
+    "Australia": "AU",
+    "Austria": "AT",
+    "Azerbaijan": "AZ",
+    "Bahamas": "BS",
+    "Bahrain": "BH",
+    "Bangladesh": "BD",
+    "Barbados": "BB",
+    "Belarus": "BY",
+    "Belgium": "BE",
+    "Belize": "BZ",
+    "Benin": "BJ",
+    "Bermuda": "BM",
+    "Bhutan": "BT",
+    "Bolivia": "BO",
+    "Bolivia, Plurinational State of": "BO",
+    "Bonaire, Sint Eustatius and Saba": "BQ",
+    "Bosnia and Herzegovina": "BA",
+    "Botswana": "BW",
+    "Bouvet Island": "BV",
+    "Brazil": "BR",
+    "Britain": "GB",
+    "British Indian Ocean Territory": "IO",
+    "Brunei": "BN",
+    "Brunei Darussalam": "BN",
+    "Bulgaria": "BG",
+    "Burkina Faso": "BF",
+    "Burundi": "BI",
+    "Cabo Verde": "CV",
+    "Cambodia": "KH",
+    "Cameroon": "CM",
+    "Canada": "CA",
+    "Cayman Islands": "KY",
+    "Central African Republic": "CF",
+    "Chad": "TD",
+    "Chile": "CL",
+    "China": "CN",
+    "Christmas Island": "CX",
+    "Cocos (Keeling) Islands": "CC",
+    "Colombia": "CO",
+    "Comoros": "KM",
+    "Congo": "CG",
+    "Congo, The Democratic Republic of the": "CD",
+    "Cook Islands": "CK",
+    "Costa Rica": "CR",
+    "Croatia": "HR",
+    "Cuba": "CU",
+    "Curaçao": "CW",
+    "Cyprus": "CY",
+    "Czech Republic": "CZ",
+    "Czechia": "CZ",
+    "Côte d'Ivoire": "CI",
+    "Denmark": "DK",
+    "Djibouti": "DJ",
+    "Dominica": "DM",
+    "Dominican Republic": "DO",
+    "Ecuador": "EC",
+    "Egypt": "EG",
+    "El Salvador": "SV",
+    "England": "GB",
+    "Equatorial Guinea": "GQ",
+    "Eritrea": "ER",
+    "Estonia": "EE",
+    "Eswatini": "SZ",
+    "Ethiopia": "ET",
+    "Falkland Islands (Malvinas)": "FK",
+    "Faroe Islands": "FO",
+    "Fiji": "FJ",
+    "Finland": "FI",
+    "France": "FR",
+    "French Guiana": "GF",
+    "French Polynesia": "PF",
+    "French Southern Territories": "TF",
+    "Gabon": "GA",
+    "Gambia": "GM",
+    "Georgia": "GE",
+    "Germany": "DE",
+    "Ghana": "GH",
+    "Gibraltar": "GI",
+    "Greece": "GR",
+    "Greenland": "GL",
+    "Grenada": "GD",
+    "Guadeloupe": "GP",
+    "Guam": "GU",
+    "Guatemala": "GT",
+    "Guernsey": "GG",
+    "Guinea": "GN",
+    "Guinea-Bissau": "GW",
+    "Guyana": "GY",
+    "Haiti": "HT",
+    "Heard Island and McDonald Islands": "HM",
+    "Holy See (Vatican City State)": "VA",
+    "Honduras": "HN",
+    "Hong Kong": "HK",
+    "Hungary": "HU",
+    "Iceland": "IS",
+    "India": "IN",
+    "Indonesia": "ID",
+    "Iran": "IR",
+    "Iran, Islamic Republic of": "IR",
+    "Iraq": "IQ",
+    "Ireland": "IE",
+    "Isle of Man": "IM",
+    "Israel": "IL",
+    "Italy": "IT",
+    "Ivory Coast": "CI",
+    "Jamaica": "JM",
+    "Japan": "JP",
+    "Jersey": "JE",
+    "Jordan": "JO",
+    "Kazakhstan": "KZ",
+    "Kenya": "KE",
+    "Kiribati": "KI",
+    "Korea, Democratic People's Republic of": "KP",
+    "Korea, Republic of": "KR",
+    "Kuwait": "KW",
+    "Kyrgyzstan": "KG",
+    "Lao People's Democratic Republic": "LA",
+    "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",
+    "Martinique": "MQ",
+    "Mauritania": "MR",
+    "Mauritius": "MU",
+    "Mayotte": "YT",
+    "Mexico": "MX",
+    "Micronesia, Federated States of": "FM",
+    "Moldova": "MD",
+    "Moldova, Republic of": "MD",
+    "Monaco": "MC",
+    "Mongolia": "MN",
+    "Montenegro": "ME",
+    "Montserrat": "MS",
+    "Morocco": "MA",
+    "Mozambique": "MZ",
+    "Myanmar": "MM",
+    "Namibia": "NA",
+    "Nauru": "NR",
+    "Nepal": "NP",
+    "Netherlands": "NL",
+    "New Caledonia": "NC",
+    "New Zealand": "NZ",
+    "Nicaragua": "NI",
+    "Niger": "NE",
+    "Nigeria": "NG",
+    "Niue": "NU",
+    "Norfolk Island": "NF",
+    "North Korea": "KP",
+    "North Macedonia": "MK",
+    "Northern Mariana Islands": "MP",
+    "Norway": "NO",
+    "Oman": "OM",
+    "Pakistan": "PK",
+    "Palau": "PW",
+    "Palestine": "PS",
+    "Palestine, State of": "PS",
+    "Panama": "PA",
+    "Papua New Guinea": "PG",
+    "Paraguay": "PY",
+    "Peru": "PE",
+    "Philippines": "PH",
+    "Pitcairn": "PN",
+    "Poland": "PL",
+    "Portugal": "PT",
+    "Puerto Rico": "PR",
+    "Qatar": "QA",
+    "Romania": "RO",
+    "Russia": "RU",
+    "Russian Federation": "RU",
+    "Rwanda": "RW",
+    "Réunion": "RE",
+    "Saint Barthélemy": "BL",
+    "Saint Helena, Ascension and Tristan da Cunha": "SH",
+    "Saint Kitts and Nevis": "KN",
+    "Saint Lucia": "LC",
+    "Saint Martin (French part)": "MF",
+    "Saint Pierre and Miquelon": "PM",
+    "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",
+    "Sint Maarten (Dutch part)": "SX",
+    "Slovakia": "SK",
+    "Slovenia": "SI",
+    "Solomon Islands": "SB",
+    "Somalia": "SO",
+    "South Africa": "ZA",
+    "South Georgia and the South Sandwich Islands": "GS",
+    "South Korea": "KR",
+    "South Sudan": "SS",
+    "Spain": "ES",
+    "Sri Lanka": "LK",
+    "Sudan": "SD",
+    "Suriname": "SR",
+    "Svalbard and Jan Mayen": "SJ",
+    "Sweden": "SE",
+    "Switzerland": "CH",
+    "Syria": "SY",
+    "Syrian Arab Republic": "SY",
+    "Taiwan": "TW",
+    "Taiwan, Province of China": "TW",
+    "Tajikistan": "TJ",
+    "Tanzania": "TZ",
+    "Tanzania, United Republic of": "TZ",
+    "Thailand": "TH",
+    "Timor-Leste": "TL",
+    "Togo": "TG",
+    "Tokelau": "TK",
+    "Tonga": "TO",
+    "Trinidad and Tobago": "TT",
+    "Tunisia": "TN",
+    "Turkey": "TR",
+    "Turkmenistan": "TM",
+    "Turks and Caicos Islands": "TC",
+    "Tuvalu": "TV",
+    "Türkiye": "TR",
+    "UAE": "AE",
+    "UK": "GB",
+    "USA": "US",
+    "Uganda": "UG",
+    "Ukraine": "UA",
+    "United Arab Emirates": "AE",
+    "United Kingdom": "GB",
+    "United States": "US",
+    "United States Minor Outlying Islands": "UM",
+    "Uruguay": "UY",
+    "Uzbekistan": "UZ",
+    "Vanuatu": "VU",
+    "Venezuela": "VE",
+    "Venezuela, Bolivarian Republic of": "VE",
+    "Viet Nam": "VN",
+    "Vietnam": "VN",
+    "Virgin Islands, British": "VG",
+    "Virgin Islands, U.S.": "VI",
+    "Wallis and Futuna": "WF",
+    "Western Sahara": "EH",
+    "Yemen": "YE",
+    "Zambia": "ZM",
+    "Zimbabwe": "ZW",
+    "Åland Islands": "AX",
+}
+CANONICAL_NAMES = {
+    "AD": "Andorra",
+    "AE": "United Arab Emirates",
+    "AF": "Afghanistan",
+    "AG": "Antigua and Barbuda",
+    "AI": "Anguilla",
+    "AL": "Albania",
+    "AM": "Armenia",
+    "AO": "Angola",
+    "AQ": "Antarctica",
+    "AR": "Argentina",
+    "AS": "American Samoa",
+    "AT": "Austria",
+    "AU": "Australia",
+    "AW": "Aruba",
+    "AX": "Åland Islands",
+    "AZ": "Azerbaijan",
+    "BA": "Bosnia and Herzegovina",
+    "BB": "Barbados",
+    "BD": "Bangladesh",
+    "BE": "Belgium",
+    "BF": "Burkina Faso",
+    "BG": "Bulgaria",
+    "BH": "Bahrain",
+    "BI": "Burundi",
+    "BJ": "Benin",
+    "BL": "Saint Barthélemy",
+    "BM": "Bermuda",
+    "BN": "Brunei Darussalam",
+    "BO": "Bolivia",
+    "BQ": "Bonaire, Sint Eustatius and Saba",
+    "BR": "Brazil",
+    "BS": "Bahamas",
+    "BT": "Bhutan",
+    "BV": "Bouvet Island",
+    "BW": "Botswana",
+    "BY": "Belarus",
+    "BZ": "Belize",
+    "CA": "Canada",
+    "CC": "Cocos (Keeling) Islands",
+    "CD": "Congo, The Democratic Republic of the",
+    "CF": "Central African Republic",
+    "CG": "Congo",
+    "CH": "Switzerland",
+    "CI": "Côte d'Ivoire",
+    "CK": "Cook Islands",
+    "CL": "Chile",
+    "CM": "Cameroon",
+    "CN": "China",
+    "CO": "Colombia",
+    "CR": "Costa Rica",
+    "CU": "Cuba",
+    "CV": "Cabo Verde",
+    "CW": "Curaçao",
+    "CX": "Christmas Island",
+    "CY": "Cyprus",
+    "CZ": "Czechia",
+    "DE": "Germany",
+    "DJ": "Djibouti",
+    "DK": "Denmark",
+    "DM": "Dominica",
+    "DO": "Dominican Republic",
+    "DZ": "Algeria",
+    "EC": "Ecuador",
+    "EE": "Estonia",
+    "EG": "Egypt",
+    "EH": "Western Sahara",
+    "ER": "Eritrea",
+    "ES": "Spain",
+    "ET": "Ethiopia",
+    "FI": "Finland",
+    "FJ": "Fiji",
+    "FK": "Falkland Islands (Malvinas)",
+    "FM": "Micronesia, Federated States of",
+    "FO": "Faroe Islands",
+    "FR": "France",
+    "GA": "Gabon",
+    "GB": "United Kingdom",
+    "GD": "Grenada",
+    "GE": "Georgia",
+    "GF": "French Guiana",
+    "GG": "Guernsey",
+    "GH": "Ghana",
+    "GI": "Gibraltar",
+    "GL": "Greenland",
+    "GM": "Gambia",
+    "GN": "Guinea",
+    "GP": "Guadeloupe",
+    "GQ": "Equatorial Guinea",
+    "GR": "Greece",
+    "GS": "South Georgia and the South Sandwich Islands",
+    "GT": "Guatemala",
+    "GU": "Guam",
+    "GW": "Guinea-Bissau",
+    "GY": "Guyana",
+    "HK": "Hong Kong",
+    "HM": "Heard Island and McDonald Islands",
+    "HN": "Honduras",
+    "HR": "Croatia",
+    "HT": "Haiti",
+    "HU": "Hungary",
+    "ID": "Indonesia",
+    "IE": "Ireland",
+    "IL": "Israel",
+    "IM": "Isle of Man",
+    "IN": "India",
+    "IO": "British Indian Ocean Territory",
+    "IQ": "Iraq",
+    "IR": "Iran",
+    "IS": "Iceland",
+    "IT": "Italy",
+    "JE": "Jersey",
+    "JM": "Jamaica",
+    "JO": "Jordan",
+    "JP": "Japan",
+    "KE": "Kenya",
+    "KG": "Kyrgyzstan",
+    "KH": "Cambodia",
+    "KI": "Kiribati",
+    "KM": "Comoros",
+    "KN": "Saint Kitts and Nevis",
+    "KP": "North Korea",
+    "KR": "South Korea",
+    "KW": "Kuwait",
+    "KY": "Cayman Islands",
+    "KZ": "Kazakhstan",
+    "LA": "Laos",
+    "LB": "Lebanon",
+    "LC": "Saint Lucia",
+    "LI": "Liechtenstein",
+    "LK": "Sri Lanka",
+    "LR": "Liberia",
+    "LS": "Lesotho",
+    "LT": "Lithuania",
+    "LU": "Luxembourg",
+    "LV": "Latvia",
+    "LY": "Libya",
+    "MA": "Morocco",
+    "MC": "Monaco",
+    "MD": "Moldova",
+    "ME": "Montenegro",
+    "MF": "Saint Martin (French part)",
+    "MG": "Madagascar",
+    "MH": "Marshall Islands",
+    "MK": "North Macedonia",
+    "ML": "Mali",
+    "MM": "Myanmar",
+    "MN": "Mongolia",
+    "MO": "Macao",
+    "MP": "Northern Mariana Islands",
+    "MQ": "Martinique",
+    "MR": "Mauritania",
+    "MS": "Montserrat",
+    "MT": "Malta",
+    "MU": "Mauritius",
+    "MV": "Maldives",
+    "MW": "Malawi",
+    "MX": "Mexico",
+    "MY": "Malaysia",
+    "MZ": "Mozambique",
+    "NA": "Namibia",
+    "NC": "New Caledonia",
+    "NE": "Niger",
+    "NF": "Norfolk Island",
+    "NG": "Nigeria",
+    "NI": "Nicaragua",
+    "NL": "Netherlands",
+    "NO": "Norway",
+    "NP": "Nepal",
+    "NR": "Nauru",
+    "NU": "Niue",
+    "NZ": "New Zealand",
+    "OM": "Oman",
+    "PA": "Panama",
+    "PE": "Peru",
+    "PF": "French Polynesia",
+    "PG": "Papua New Guinea",
+    "PH": "Philippines",
+    "PK": "Pakistan",
+    "PL": "Poland",
+    "PM": "Saint Pierre and Miquelon",
+    "PN": "Pitcairn",
+    "PR": "Puerto Rico",
+    "PS": "Palestine, State of",
+    "PT": "Portugal",
+    "PW": "Palau",
+    "PY": "Paraguay",
+    "QA": "Qatar",
+    "RE": "Réunion",
+    "RO": "Romania",
+    "RS": "Serbia",
+    "RU": "Russian Federation",
+    "RW": "Rwanda",
+    "SA": "Saudi Arabia",
+    "SB": "Solomon Islands",
+    "SC": "Seychelles",
+    "SD": "Sudan",
+    "SE": "Sweden",
+    "SG": "Singapore",
+    "SH": "Saint Helena, Ascension and Tristan da Cunha",
+    "SI": "Slovenia",
+    "SJ": "Svalbard and Jan Mayen",
+    "SK": "Slovakia",
+    "SL": "Sierra Leone",
+    "SM": "San Marino",
+    "SN": "Senegal",
+    "SO": "Somalia",
+    "SR": "Suriname",
+    "SS": "South Sudan",
+    "ST": "Sao Tome and Principe",
+    "SV": "El Salvador",
+    "SX": "Sint Maarten (Dutch part)",
+    "SY": "Syria",
+    "SZ": "Eswatini",
+    "TC": "Turks and Caicos Islands",
+    "TD": "Chad",
+    "TF": "French Southern Territories",
+    "TG": "Togo",
+    "TH": "Thailand",
+    "TJ": "Tajikistan",
+    "TK": "Tokelau",
+    "TL": "Timor-Leste",
+    "TM": "Turkmenistan",
+    "TN": "Tunisia",
+    "TO": "Tonga",
+    "TR": "Türkiye",
+    "TT": "Trinidad and Tobago",
+    "TV": "Tuvalu",
+    "TW": "Taiwan",
+    "TZ": "Tanzania",
+    "UA": "Ukraine",
+    "UG": "Uganda",
+    "UM": "United States Minor Outlying Islands",
+    "US": "United States",
+    "UY": "Uruguay",
+    "UZ": "Uzbekistan",
+    "VA": "Holy See (Vatican City State)",
+    "VC": "Saint Vincent and the Grenadines",
+    "VE": "Venezuela",
+    "VG": "Virgin Islands, British",
+    "VI": "Virgin Islands, U.S.",
+    "VN": "Vietnam",
+    "VU": "Vanuatu",
+    "WF": "Wallis and Futuna",
+    "WS": "Samoa",
+    "YE": "Yemen",
+    "YT": "Mayotte",
+    "ZA": "South Africa",
+    "ZM": "Zambia",
+    "ZW": "Zimbabwe",
+}

veil_cli-0.1.0/app/netinfo.py ADDED Viewed

@@ -0,0 +1,109 @@
+from __future__ import annotations
+import re
+import socket
+from dataclasses import dataclass, field
+import requests
+HTTP_TIMEOUT = 8
+GEOIP_URL = "http://ip-api.com/json/{ip}?fields=status,message,country,countryCode,isp,org,as"
+TITLE_RE = re.compile(rb"<title[^>]*>(.*?)</title>", re.IGNORECASE | re.DOTALL)
+@dataclass
+class SiteDetails:
+    domain: str
+    ip: str | None = None
+    resolve_error: str | None = None
+    http_status: int | None = None
+    http_error: str | None = None
+    server_header: str | None = None
+    title: str | None = None
+    final_url: str | None = None
+    isp: str | None = None
+    org: str | None = None
+    asn: str | None = None
+    host_country: str | None = None
+def _clean_domain(raw: str) -> str:
+    raw = raw.strip()
+    raw = re.sub(r"^\w+://", "", raw)
+    raw = raw.split("/")[0]
+    raw = raw.split(":")[0]
+    return raw
+def resolve(domain: str) -> tuple[str | None, str | None]:
+    try:
+        ip = socket.gethostbyname(domain)
+        return ip, None
+    except socket.gaierror as exc:
+        return None, str(exc)
+def probe_http(domain: str) -> dict:
+    out = {"http_status": None, "http_error": None, "server_header": None,
+            "title": None, "final_url": None}
+    for scheme in ("https", "http"):
+        url = f"{scheme}://{domain}"
+        try:
+            resp = requests.get(
+                url,
+                timeout=HTTP_TIMEOUT,
+                headers={"User-Agent": "Mozilla/5.0 (compatible; veil-cli/0.1)"},
+                allow_redirects=True,
+            )
+            out["http_status"] = resp.status_code
+            out["server_header"] = resp.headers.get("Server")
+            out["final_url"] = resp.url
+            match = TITLE_RE.search(resp.content[:8192])
+            if match:
+                title = match.group(1).decode("utf-8", errors="ignore")
+                out["title"] = re.sub(r"\s+", " ", title).strip()[:120]
+            return out
+        except requests.RequestException as exc:
+            out["http_error"] = str(exc)
+            continue
+    return out
+def geoip_lookup(ip: str) -> dict:
+    out = {"isp": None, "org": None, "asn": None, "host_country": None}
+    try:
+        resp = requests.get(GEOIP_URL.format(ip=ip), timeout=6)
+        data = resp.json()
+        if data.get("status") == "success":
+            out["isp"] = data.get("isp")
+            out["org"] = data.get("org")
+            out["asn"] = data.get("as")
+            out["host_country"] = data.get("country")
+    except (requests.RequestException, ValueError):
+        pass
+    return out
+def gather_site_details(raw_domain: str) -> SiteDetails:
+    domain = _clean_domain(raw_domain)
+    details = SiteDetails(domain=domain)
+    ip, err = resolve(domain)
+    details.ip = ip
+    details.resolve_error = err
+    if ip:
+        http_info = probe_http(domain)
+        details.http_status = http_info["http_status"]
+        details.http_error = http_info["http_error"]
+        details.server_header = http_info["server_header"]
+        details.title = http_info["title"]
+        details.final_url = http_info["final_url"]
+        geo = geoip_lookup(ip)
+        details.isp = geo["isp"]
+        details.org = geo["org"]
+        details.asn = geo["asn"]
+        details.host_country = geo["host_country"]
+    return details

veil_cli-0.1.0/app/ooni.py ADDED Viewed

@@ -0,0 +1,158 @@
+from __future__ import annotations
+import datetime as _dt
+import time
+from dataclasses import dataclass
+import requests
+API_BASE = "https://api.ooni.io/api/v1/aggregation"
+USER_AGENT = "veil-cli/0.1 (+https://ooni.org)"
+TIMEOUT = 120
+MIN_RELIABLE_MEASUREMENTS = 5
+ANOMALY_RATIO_THRESHOLD = 0.3
+LIST_WINDOWS_DAYS = [365, 180, 90, 30, 14]
+@dataclass
+class CountryVerdict:
+    country_code: str
+    measurement_count: int
+    confirmed_count: int
+    anomaly_count: int
+    ok_count: int
+    failure_count: int
+    @property
+    def anomaly_ratio(self) -> float:
+        if self.measurement_count == 0:
+            return 0.0
+        return (self.anomaly_count + self.confirmed_count) / self.measurement_count
+    @property
+    def status(self) -> str:
+        if self.measurement_count < MIN_RELIABLE_MEASUREMENTS:
+            return "no_data"
+        if self.confirmed_count > 0:
+            return "blocked"
+        if self.anomaly_ratio >= ANOMALY_RATIO_THRESHOLD:
+            return "likely_blocked"
+        return "reachable"
+class OoniError(RuntimeError):
+    pass
+def _default_since_country(years_back: int = 1) -> str:
+    d = _dt.date.today() - _dt.timedelta(days=365 * years_back)
+    return d.isoformat()
+def _since_days_ago(days_back: int) -> str:
+    d = _dt.date.today() - _dt.timedelta(days=days_back)
+    return d.isoformat()
+def _default_until() -> str:
+    return _dt.date.today().isoformat()
+def _get(params: dict, retries: int = 2) -> dict:
+    last_exc = None
+    for attempt in range(retries):
+        try:
+            resp = requests.get(
+                API_BASE,
+                params=params,
+                headers={"User-Agent": USER_AGENT},
+                timeout=TIMEOUT,
+            )
+            if resp.status_code >= 500:
+                last_exc = OoniError(f"OONI's server is overloaded (HTTP {resp.status_code})")
+                time.sleep(2 * (attempt + 1))
+                continue
+            resp.raise_for_status()
+            return resp.json()
+        except requests.RequestException as exc:
+            last_exc = OoniError(f"couldn't reach the OONI API: {exc}")
+            time.sleep(2 * (attempt + 1))
+        except ValueError as exc:
+            raise OoniError("OONI API returned a non-JSON response") from exc
+    raise last_exc
+def aggregate_for_country(
+    domain: str,
+    country_code: str,
+    since: str | None = None,
+    until: str | None = None,
+) -> CountryVerdict:
+    params = {
+        "domain": domain,
+        "probe_cc": country_code.upper(),
+        "test_name": "web_connectivity",
+        "since": since or _default_since_country(),
+        "until": until or _default_until(),
+    }
+    data = _get(params)
+    result = data.get("result") or {}
+    if isinstance(result, list):
+        result = result[0] if result else {}
+    return CountryVerdict(
+        country_code=country_code.upper(),
+        measurement_count=result.get("measurement_count", 0) or 0,
+        confirmed_count=result.get("confirmed_count", 0) or 0,
+        anomaly_count=result.get("anomaly_count", 0) or 0,
+        ok_count=result.get("ok_count", 0) or 0,
+        failure_count=result.get("failure_count", 0) or 0,
+    )
+def aggregate_by_country(
+    domain: str,
+    until: str | None = None,
+) -> tuple[list[CountryVerdict], int]:
+    """Returns (verdicts, days_used) — tries the widest window first for the
+    best data coverage, and only falls back to a narrower window if OONI's
+    backend can't complete the query in time."""
+    last_exc = None
+    for days in LIST_WINDOWS_DAYS:
+        params = {
+            "domain": domain,
+            "axis_x": "probe_cc",
+            "test_name": "web_connectivity",
+            "since": _since_days_ago(days),
+            "until": until or _default_until(),
+        }
+        try:
+            data = _get(params, retries=2)
+        except OoniError as exc:
+            last_exc = exc
+            continue
+        rows = data.get("result") or []
+        verdicts = []
+        for row in rows:
+            cc = row.get("probe_cc")
+            if not cc or cc == "ZZ":
+                continue
+            verdicts.append(
+                CountryVerdict(
+                    country_code=cc,
+                    measurement_count=row.get("measurement_count", 0) or 0,
+                    confirmed_count=row.get("confirmed_count", 0) or 0,
+                    anomaly_count=row.get("anomaly_count", 0) or 0,
+                    ok_count=row.get("ok_count", 0) or 0,
+                    failure_count=row.get("failure_count", 0) or 0,
+                )
+            )
+        verdicts.sort(
+            key=lambda v: (v.confirmed_count, v.anomaly_count, v.measurement_count),
+            reverse=True,
+        )
+        return verdicts, days
+    raise last_exc

veil_cli-0.1.0/app/ui.py ADDED Viewed

@@ -0,0 +1,267 @@
+from __future__ import annotations
+import sys
+from rich.align import Align
+from rich.box import ROUNDED
+from rich.console import Console, Group
+from rich.padding import Padding
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+from app.ooni import CountryVerdict, MIN_RELIABLE_MEASUREMENTS
+from app.netinfo import SiteDetails
+WHITE = "white"
+GREY = "grey62"
+LOGO = r"""__   _____ ___ _
+\ \ / / __|_ _| |
+ \ V /| _| | || |__
+  \_/ |___|___|____|
+  """
+console = Console(highlight=False)
+def clear_screen() -> None:
+    console.clear()
+STATUS_STYLE = {
+    "blocked": ("BLOCKED", "confirmed by OONI probes"),
+    "likely_blocked": ("LIKELY BLOCKED", "high anomaly rate in probe data"),
+    "reachable": ("REACHABLE", "no significant blocking signal"),
+    "no_data": ("NO DATA", "not enough OONI measurements to judge"),
+}
+STATUS_PRIORITY = {"blocked": 0, "likely_blocked": 1, "reachable": 2, "no_data": 3}
+def print_banner() -> None:
+    logo = Text(LOGO, style=f"bold {WHITE}")
+    tagline = Text("  ·  an OSINT tool that checks whether a site is blocked in a given country  ·  ", style=GREY)
+    console.print()
+    console.print(Align.center(logo))
+    console.print(Align.center(tagline))
+    console.print()
+def print_intro_box() -> None:
+    body = Text()
+    body.append("Type a site to scan it, e.g. ", style=GREY)
+    body.append("youtube.com", style=f"bold {WHITE}")
+    body.append("\n")
+    body.append("Then a country code (or name), e.g. ", style=GREY)
+    body.append("PS", style=f"bold {WHITE}")
+    body.append(" or ", style=GREY)
+    body.append("Palestine", style=f"bold {WHITE}")
+    body.append(", leave blank to see all blocked countries.\n\n", style=GREY)
+    body.append("Commands: ", style=GREY)
+    body.append("help", style=f"bold {WHITE}")
+    body.append("  ", style=GREY)
+    body.append("exit", style=f"bold {WHITE}")
+    panel = Panel(
+        body,
+        title="[bold]what to do[/bold]",
+        title_align="left",
+        border_style=GREY,
+        box=ROUNDED,
+        padding=(1, 2),
+    )
+    console.print(panel)
+    console.print()
+def prompt_in_box(label: str) -> str:
+    width = min(console.width - 4, 70)
+    inner_width = width - 2
+    top = f"╭{'─' * inner_width}╮"
+    bottom = f"╰{'─' * inner_width}╯"
+    prefix_visible = f" › {label} "
+    padding_len = max(0, inner_width - len(prefix_visible))
+    console.print(f"[{GREY}]{top}[/{GREY}]")
+    console.print(
+        f"[{GREY}]│[/{GREY}][bold {WHITE}] [/bold {WHITE}][{GREY}]› [/{GREY}]"
+        f"{label} {' ' * padding_len}[{GREY}]│[/{GREY}]"
+    )
+    console.print(f"[{GREY}]{bottom}[/{GREY}]")
+    input_col = len(prefix_visible) + 2
+    sys.stdout.write(f"\x1b[2A\x1b[{input_col}G")
+    sys.stdout.flush()
+    value = input().strip()
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+    return value
+def prompt_site() -> str:
+    return prompt_in_box("site to scan = ")
+def prompt_country() -> str:
+    return prompt_in_box("country (leave it blank to list all) = ")
+def status_line(msg: str, style: str = GREY) -> None:
+    console.print(f"[{style}]{msg}[/{style}]")
+def error_line(msg: str) -> None:
+    console.print(f"[bold {WHITE}]✕ {msg}[/bold {WHITE}]")
+def spinner(message: str):
+    return console.status(f"[{GREY}]{message}[/{GREY}]", spinner="dots")
+def render_site_details(details: SiteDetails) -> None:
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style=GREY, justify="right")
+    table.add_column(style=WHITE)
+    table.add_row("domain", details.domain)
+    if details.resolve_error:
+        table.add_row("resolve", f"[bold {WHITE}]failed — {details.resolve_error}[/bold {WHITE}]")
+        console.print(
+            Panel(table, title="[bold]site details[/bold]", title_align="left",
+                  border_style=GREY, box=ROUNDED, padding=(1, 2))
+        )
+        return
+    table.add_row("ip", details.ip or "—")
+    if details.org or details.isp:
+        table.add_row("host", details.org or details.isp or "—")
+    if details.asn:
+        table.add_row("asn", details.asn)
+    if details.host_country:
+        table.add_row("hosted in", details.host_country)
+    if details.http_status:
+        table.add_row("http", f"[bold {WHITE}]{details.http_status}[/bold {WHITE}]"
+                               f"  ({details.final_url})")
+    elif details.http_error:
+        table.add_row("http", f"[{GREY}]unreachable from here[/{GREY}]")
+    if details.title:
+        table.add_row("title", details.title)
+    console.print(
+        Panel(table, title="[bold]site details[/bold]", title_align="left",
+              border_style=GREY, box=ROUNDED, padding=(1, 2))
+    )
+def render_country_verdict(verdict: CountryVerdict, country_label: str) -> None:
+    label, note = STATUS_STYLE[verdict.status]
+    header = Text()
+    header.append(f"{country_label} ({verdict.country_code})  ", style=f"bold {WHITE}")
+    header.append(label, style=f"bold {WHITE}")
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style=GREY, justify="right")
+    table.add_column(style=WHITE)
+    table.add_row("measurements", str(verdict.measurement_count))
+    table.add_row("confirmed blocked", str(verdict.confirmed_count))
+    table.add_row("anomalous", str(verdict.anomaly_count))
+    table.add_row("ok", str(verdict.ok_count))
+    table.add_row("note", note)
+    console.print(
+        Panel(
+            Group(header, Text(""), table),
+            title="[bold]block status[/bold]",
+            title_align="left",
+            border_style=GREY,
+            box=ROUNDED,
+            padding=(1, 2),
+        )
+    )
+def render_country_list(
+    verdicts: list[CountryVerdict],
+    domain: str,
+    days_used: int | None = None,
+    page_size: int = 20,
+) -> None:
+    if not verdicts:
+        console.print(Panel(
+            f"No OONI measurement data found for [bold {WHITE}]{domain}[/bold {WHITE}].",
+            border_style=GREY, box=ROUNDED, padding=(1, 2),
+        ))
+        return
+    counts = {"blocked": 0, "likely_blocked": 0, "reachable": 0, "no_data": 0}
+    for v in verdicts:
+        counts[v.status] += 1
+    ordered = sorted(
+        verdicts,
+        key=lambda v: (STATUS_PRIORITY[v.status], -v.confirmed_count, -v.anomaly_count, -v.measurement_count),
+    )
+    pages = [ordered[i:i + page_size] for i in range(0, len(ordered), page_size)]
+    window_note = f" (last {days_used} days)" if days_used else ""
+    for page_num, page in enumerate(pages, start=1):
+        table = Table(
+            box=ROUNDED, border_style=GREY, show_lines=False,
+            title=f"countries with data for [bold {WHITE}]{domain}[/bold {WHITE}]{window_note}"
+                  f"  —  page {page_num}/{len(pages)}",
+            title_justify="left",
+        )
+        table.add_column("country", style=WHITE)
+        table.add_column("status", justify="left", style=WHITE)
+        table.add_column("confirmed", justify="right", style=GREY)
+        table.add_column("anomalous", justify="right", style=GREY)
+        table.add_column("measurements", justify="right", style=GREY)
+        for v in page:
+            label, _ = STATUS_STYLE[v.status]
+            table.add_row(
+                v.country_code,
+                label,
+                str(v.confirmed_count),
+                str(v.anomaly_count),
+                str(v.measurement_count),
+            )
+        with console.capture() as capture:
+            console.print(table)
+        rendered = capture.get()
+        console.file.write(rendered)
+        console.file.flush()
+        table_lines = rendered.count("\n")
+        if page_num < len(pages):
+            console.input(f"[{GREY}]-- press Enter for next page ({page_num}/{len(pages)}) --[/{GREY}] ")
+            lines_to_clear = table_lines + 1
+            sys.stdout.write(f"\x1b[{lines_to_clear}A\x1b[0J")
+            sys.stdout.flush()
+    summary = Text()
+    summary.append(f"{counts['blocked']} blocked", style=f"bold {WHITE}")
+    summary.append("  ·  ", style=GREY)
+    summary.append(f"{counts['likely_blocked']} likely blocked", style=f"bold {WHITE}")
+    summary.append("  ·  ", style=GREY)
+    summary.append(f"{counts['reachable']} reachable", style=GREY)
+    summary.append("  ·  ", style=GREY)
+    summary.append(f"{counts['no_data']} no data (fewer than {MIN_RELIABLE_MEASUREMENTS} measurements)", style=GREY)
+    console.print(Padding(summary, (0, 1)))
+def print_help() -> None:
+    console.print(Panel(
+        f"[bold {WHITE}]veil <site>[/bold {WHITE}] [{GREY}][--country CC] [--list][/{GREY}]\n\n"
+        "Run with no arguments to start an interactive session.\n"
+        "In the session, just type a domain, then a country (or leave it "
+        "blank to see every country with blocking signal).\n\n"
+        f"[{GREY}]Data comes from OONI's crowdsourced probe network — treat "
+        f"results as a strong signal, not certainty.[/{GREY}]",
+        title="[bold]help[/bold]", title_align="left",
+        border_style=GREY, box=ROUNDED, padding=(1, 2),
+    ))

veil_cli-0.1.0/pyproject.toml ADDED Viewed

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "veil-cli"
+version = "0.1.0"
+description = "Check whether a site is blocked in a given country, using OONI data."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "requests>=2.28",
+    "rich>=13.0",
+]
+[project.scripts]
+veil = "app.cli:main"
+[tool.setuptools]
+packages = ["app"]

veil_cli-0.1.0/setup.cfg ADDED Viewed

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build =
+tag_date = 0

veil_cli-0.1.0/veil_cli.egg-info/PKG-INFO ADDED Viewed

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: veil-cli
+Version: 0.1.0
+Summary: Check whether a site is blocked in a given country, using OONI data.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: rich>=13.0

veil_cli-0.1.0/veil_cli.egg-info/SOURCES.txt ADDED Viewed

@@ -0,0 +1,14 @@
+pyproject.toml
+app/__init__.py
+app/__main__.py
+app/cli.py
+app/country_table.py
+app/netinfo.py
+app/ooni.py
+app/ui.py
+veil_cli.egg-info/PKG-INFO
+veil_cli.egg-info/SOURCES.txt
+veil_cli.egg-info/dependency_links.txt
+veil_cli.egg-info/entry_points.txt
+veil_cli.egg-info/requires.txt
+veil_cli.egg-info/top_level.txt

veil_cli-0.1.0/veil_cli.egg-info/dependency_links.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+

veil_cli-0.1.0/veil_cli.egg-info/entry_points.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ [console_scripts]
2	+ veil = app.cli:main

veil_cli-0.1.0/veil_cli.egg-info/requires.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ requests>=2.28
2	+ rich>=13.0

veil_cli-0.1.0/veil_cli.egg-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ app