yougotmapped 1.0.0__tar.gz

yougotmapped-1.0.0/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2025 diputs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+📝 Side note from the author:
+If this script crashes your terminal or geo-locates your toaster... that's on you.  
+But hey — it worked flawlessly on my end. 🫠

yougotmapped-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

yougotmapped-1.0.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: yougotmapped
+Version: 1.0.0
+Summary: A terminal tool to map IPs and domains with style.
+Home-page: https://github.com/diputs-sudo/YouGotMapped
+Author: diputs
+Author-email: diputs-sudo@proton.me
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: folium
+Requires-Dist: python-dotenv
+Requires-Dist: ping3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🌍 YouGotMapped — IP Geolocation Mapper
+
+Ever wondered where that weird IP pinging your router is *actually* from? 
+Or maybe you're just nosy (respect). Either way — this script's for you.
+
+**YouGotMapped** is a sassy little Python tool that:
+- Auto-fetches your IP (if you dare expose yourself)
+- Accepts any domain or IP you throw at it
+- Contacts the internet (politely) for geo intel
+- Drops a sweet, interactive map
+
+---
+
+## ✨ Features
+
+- Lookup **IP addresses** or **domains** like a pro hacker wannabe
+- Detects your public IP like "hi, it's me"
+- Maps exact-ish coordinates using [ipinfo.io](https://ipinfo.io)
+- Generates a **live HTML map** with red circle vibes
+- Dependency check? Yup — it acts like a cool installer
+- Quietly avoids private IPs (don’t be that guy)
+- Clean, modular CLI with argparse support
+
+---
+
+## 🛠️ Requirements
+
+- Python 3.7+
+- Packages: `requests`, `folium`, ... (or let the script install it for you!)
+- A totally-free `IPINFO_TOKEN` (get it [here](https://ipinfo.io/signup))
+
+---
+
+## 🚀 Run It Like a Legend
+
+use pip !
+
+```bash
+pip install yougotmapped
+```
+
+```bash
+# Clone the repo
+git clone https://github.com/Zynk-dot/YouGotMapped.git
+cd YouGotMapped
+
+# Option 1: Set token temporarily
+export IPINFO_TOKEN=your_ipinfo_token
+
+# Option 2: Let the script prompt you and save it to .env
+
+# Run the thing
+$ python3 yougotmapped.py
+```
+
+Then follow the prompts like a civilized hacker. You can:
+- Press Enter to map **your own IP** (hello, paranoia)
+- Or enter someone else's... 👀 (just be cool about it)
+
+---
+
+## 🧪 What You Get
+
+- A readout of city, region, country, and more
+- A *Google Maps-esque* HTML file you can open in your browser
+- Optional delete at the end (for sneaky folks)
+
+**File:** `ip_geolocation_map.html`
+
+You can keep it. Frame it. Or trash it like a spy after a mission.
+
+---
+
+## 🔐 Security Hints
+
+- We only send your query to **ipinfo.io** — no creepy business
+- Private IPs are blocked because that’s just weird
+- API token is pulled from env vars (no hardcoded sins here)
+
+---
+
+## 🙋 Who Made This?
+
+> Created by a ghost.   
+> No name, no trace, no problem.
+
+Contact? Nah, we don’t do that here.    
+If it breaks, fix it yourself — you're clearly smart enough to run this.    
+
+---
+
+## ⭐ Why Star This Repo?
+
+Because it's:
+- Actually useful
+- Small but mighty
+- Funny
+- And you’re already here reading this — go on, click ⭐
+
+> This repo was cloned 30+ times before it even had a README. That’s how you know it slaps.
+
+Thanks for checking this out.
+You got mapped! 🗺️

yougotmapped-1.0.0/README.md

@@ -0,0 +1,103 @@
+# 🌍 YouGotMapped — IP Geolocation Mapper
+
+Ever wondered where that weird IP pinging your router is *actually* from? 
+Or maybe you're just nosy (respect). Either way — this script's for you.
+
+**YouGotMapped** is a sassy little Python tool that:
+- Auto-fetches your IP (if you dare expose yourself)
+- Accepts any domain or IP you throw at it
+- Contacts the internet (politely) for geo intel
+- Drops a sweet, interactive map
+
+---
+
+## ✨ Features
+
+- Lookup **IP addresses** or **domains** like a pro hacker wannabe
+- Detects your public IP like "hi, it's me"
+- Maps exact-ish coordinates using [ipinfo.io](https://ipinfo.io)
+- Generates a **live HTML map** with red circle vibes
+- Dependency check? Yup — it acts like a cool installer
+- Quietly avoids private IPs (don’t be that guy)
+- Clean, modular CLI with argparse support
+
+---
+
+## 🛠️ Requirements
+
+- Python 3.7+
+- Packages: `requests`, `folium`, ... (or let the script install it for you!)
+- A totally-free `IPINFO_TOKEN` (get it [here](https://ipinfo.io/signup))
+
+---
+
+## 🚀 Run It Like a Legend
+
+use pip !
+
+```bash
+pip install yougotmapped
+```
+
+```bash
+# Clone the repo
+git clone https://github.com/Zynk-dot/YouGotMapped.git
+cd YouGotMapped
+
+# Option 1: Set token temporarily
+export IPINFO_TOKEN=your_ipinfo_token
+
+# Option 2: Let the script prompt you and save it to .env
+
+# Run the thing
+$ python3 yougotmapped.py
+```
+
+Then follow the prompts like a civilized hacker. You can:
+- Press Enter to map **your own IP** (hello, paranoia)
+- Or enter someone else's... 👀 (just be cool about it)
+
+---
+
+## 🧪 What You Get
+
+- A readout of city, region, country, and more
+- A *Google Maps-esque* HTML file you can open in your browser
+- Optional delete at the end (for sneaky folks)
+
+**File:** `ip_geolocation_map.html`
+
+You can keep it. Frame it. Or trash it like a spy after a mission.
+
+---
+
+## 🔐 Security Hints
+
+- We only send your query to **ipinfo.io** — no creepy business
+- Private IPs are blocked because that’s just weird
+- API token is pulled from env vars (no hardcoded sins here)
+
+---
+
+## 🙋 Who Made This?
+
+> Created by a ghost.   
+> No name, no trace, no problem.
+
+Contact? Nah, we don’t do that here.    
+If it breaks, fix it yourself — you're clearly smart enough to run this.    
+
+---
+
+## ⭐ Why Star This Repo?
+
+Because it's:
+- Actually useful
+- Small but mighty
+- Funny
+- And you’re already here reading this — go on, click ⭐
+
+> This repo was cloned 30+ times before it even had a README. That’s how you know it slaps.
+
+Thanks for checking this out.
+You got mapped! 🗺️

yougotmapped-1.0.0/setup.cfg

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

yougotmapped-1.0.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="yougotmapped",
+    version="1.0.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "requests",
+        "folium",
+        "python-dotenv",
+        "ping3"
+    ],
+    entry_points={
+        "console_scripts": [
+            "yougotmapped = yougotmapped.cli:main"
+        ]
+    },
+    author="diputs",
+    author_email="diputs-sudo@proton.me",
+    description="A terminal tool to map IPs and domains with style.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/diputs-sudo/YouGotMapped",
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

yougotmapped-1.0.0/yougotmapped/cli.py

@@ -0,0 +1,175 @@
+import os
+import sys
+import argparse
+import ipaddress
+from datetime import datetime
+from pathlib import Path
+
+from yougotmapped.utils.dependencies import check_dependencies
+from yougotmapped.utils.network import get_public_ip, get_geolocation, resolve_domain_to_ip
+from yougotmapped.utils.mapping import plot_ip_location, plot_multiple_ip_locations
+from yougotmapped.utils.token import get_api_token
+from yougotmapped.utils.ping import ping_target
+from yougotmapped.utils.trace import run_traceroute
+from yougotmapped.utils.anonymity import detect_anonymity, format_anonymity_result
+from yougotmapped.utils.output import write_formatted_output
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Geolocate one or more IPs/domains and generate an interactive map.")
+    parser.add_argument('-i', '--ip', nargs='*', help="One or more IPs/domains separated by space")
+    parser.add_argument('-f', '--file', type=str, help="Path to a file containing IPs/domains (one per line)")
+    parser.add_argument('-p', '--ping', action='store_true', help="Ping each IP or domain and show latency")
+    parser.add_argument('-t', '--trace', action='store_true', help="Show traceroute to each IP or domain")
+    parser.add_argument('-c', '--hidecheck', action='store_true', help="Check if the IP is a Tor exit node or VPN")
+    parser.add_argument('-o', '--output', type=str, help="Specify output file or use format shorthand (e.g., f:csv, f:json, f:normal)")
+    parser.add_argument('--no-map', action='store_true', help="Do not generate a map")
+    parser.add_argument('--delete-map', action='store_true', help="Delete the map after generating")
+    args = parser.parse_args()
+
+    check_dependencies()
+
+    API_TOKEN = get_api_token()
+    if not API_TOKEN:
+        return
+
+    targets = []
+
+    if args.ip:
+        targets.extend(args.ip)
+
+    if args.file:
+        try:
+            with open(args.file, 'r') as f:
+                targets.extend(line.strip() for line in f if line.strip())
+        except FileNotFoundError:
+            print(f"File not found: {args.file}")
+            return
+
+    if not targets:
+        print("No IP or file input provided. Defaulting to public IP lookup.")
+        ip_or_domain = get_public_ip()
+        if not ip_or_domain:
+            print("Could not determine your public IP.")
+            return
+        targets = [ip_or_domain]
+
+    geolocated = []  
+    full_results = [] 
+
+    for target in targets:
+        target_result = {}
+        try:
+            ipaddress.ip_address(target)
+            ip_or_domain = target
+        except ValueError:
+            resolved_ip = resolve_domain_to_ip(target)
+            if resolved_ip:
+                ip_or_domain = resolved_ip
+            else:
+                print(f"Skipping unresolved domain: {target}")
+                continue
+
+        print(f"Looking up location for {target}...")
+        data = get_geolocation(ip_or_domain, API_TOKEN)
+        if data:
+            geolocated.append(data)
+            target_result.update(data)
+            print("---")
+            for key in ['ip', 'hostname', 'city', 'region', 'country', 'loc', 'org', 'postal', 'timezone']:
+                print(f"{key.title()}: {data.get(key, 'N/A')}")
+
+            if args.ping:
+                print("\n[ PING RESULT ]")
+                ping_result = ping_target(target)
+                print(ping_result)
+                target_result["ping"] = ping_result
+
+            if args.trace:
+                print("\n[ TRACEROUTE RESULT ]")
+                trace_output = run_traceroute(target)
+                print(trace_output)
+                target_result["traceroute"] = trace_output
+            
+            if args.hidecheck:
+                print("\n[ ANONYMITY CHECK ]")
+                anonymity = detect_anonymity(data)
+                format_anonymity_result(anonymity)
+                target_result["anonymity"] = anonymity
+
+            print("---")
+            full_results.append(target_result)
+        else:
+            print(f"Failed to get location data for {target}.")
+
+    # --- Output & Summary ---
+    map_saved = False
+    map_path = Path("ip_geolocation_map.html").resolve()
+    log_path = None
+
+    if not args.no_map and geolocated:
+        if len(geolocated) == 1:
+            m = plot_ip_location(geolocated[0], color="red")
+
+            if args.trace and isinstance(trace_output, str):
+                lines = trace_output.strip().split("\n")
+                for line in reversed(lines):
+                    if "(" in line and ")" in line:
+                        last_ip = line.split()[1]
+                        try:
+                            ipaddress.ip_address(last_ip)
+                            last_data = get_geolocation(last_ip, API_TOKEN)
+                            if last_data:
+                                plot_ip_location(last_data, color="blue", map_object=m)
+                        except Exception:
+                            pass
+                        break
+            if m:
+                m.save(str(map_path))
+                map_saved = True
+
+        elif len(geolocated) > 1:
+            plot_multiple_ip_locations(geolocated)
+            map_saved = True
+
+    if args.delete_map:
+        try:
+            os.remove(map_path)
+            map_saved = False
+        except FileNotFoundError:
+            pass
+
+    if args.output:
+        os.makedirs("logs", exist_ok=True)
+        now = datetime.now()
+        date_str = now.strftime("%m-%d-%y")
+        time_str = now.strftime("%H-%M")
+
+        if args.output.startswith("f:"):
+            fmt_type = args.output[2:].lower()
+            ext = {"json": "json", "csv": "csv"}.get(fmt_type, "txt")
+            target_name = targets[0].replace(":", "-").replace("/", "-")
+            filename = f"{target_name}--{date_str}--{time_str}--YouGotMapped.{ext}"
+        else:
+            filename = args.output
+            fmt_type = filename.split('.')[-1].lower()
+            if fmt_type not in ["json", "csv", "txt"]:
+                fmt_type = "normal"
+
+        log_path = Path("logs") / filename
+        write_formatted_output(full_results, str(log_path), fmt_type=fmt_type)
+        log_path = log_path.resolve()
+
+    # Final summary
+    if map_saved or log_path:
+        print("\n----- OUTPUT SUMMARY -----")
+        if map_saved:
+            print(f"Map Location: {map_path}")
+            print(f"Map URL: file://{map_path}")
+        if log_path:
+            print(f"Log File: {log_path}")
+            print(f"Log URL: file://{log_path}")
+
+
+if __name__ == "__main__":
+    main()

yougotmapped-1.0.0/yougotmapped/utils/anonymity.py

@@ -0,0 +1,53 @@
+# utils/anonymity.py
+import requests
+import socket
+
+TOR_EXIT_LIST = "https://check.torproject.org/torbulkexitlist"
+
+VPN_KEYWORDS = [
+    "vpn", "m247", "nord", "express", "ovh", "digitalocean", "linode",
+    "datacamp", "host", "colo", "server", "vultr", "heficed", "leaseweb"
+]
+
+
+def is_tor_exit_node(ip):
+    try:
+        response = requests.get(TOR_EXIT_LIST, timeout=5)
+        exit_nodes = response.text.strip().splitlines()
+        return ip in exit_nodes
+    except Exception:
+        return False
+
+
+def detect_anonymity(ip_data):
+    org = ip_data.get("org", "").lower()
+    hostname = ip_data.get("hostname", "").lower()
+    ip = ip_data.get("ip")
+
+    tor = is_tor_exit_node(ip)
+    vpn = any(keyword in org or keyword in hostname for keyword in VPN_KEYWORDS)
+
+    result = {
+        "ip": ip,
+        "tor": tor,
+        "vpn": vpn,
+        "org": org,
+        "hostname": hostname,
+    }
+
+    return result
+
+
+def format_anonymity_result(result):
+    ip = result["ip"]
+    print(f"IP: {ip}")
+    print(f"Org: {result['org'] or 'N/A'}")
+    print(f"Hostname: {result['hostname'] or 'N/A'}")
+    if result['tor']:
+        print("Tor Exit Node: YES")
+    else:
+        print("Tor Exit Node: No")
+    if result['vpn']:
+        print("VPN / Proxy Suspected: YES")
+    else:
+        print("VPN / Proxy Suspected: No")

yougotmapped-1.0.0/yougotmapped/utils/dependencies.py

@@ -0,0 +1,33 @@
+# utils/dependencies.py
+import importlib.util
+import subprocess
+import sys
+
+
+def check_dependencies():
+    required = {
+        "requests": "requests",
+        "folium": "folium",
+        "ping3": "ping3",
+        "python-dotenv": "dotenv"
+    }
+
+    print("\nChecking dependencies:\n")
+
+    for package_name, module_name in required.items():
+        spec = importlib.util.find_spec(module_name)
+        if spec is not None:
+            print(f"   [OK] {package_name} found")
+        else:
+            print(f"   [MISSING] {package_name} not found")
+            choice = input(f"   Install '{package_name}' now? (yes/no): ").strip().lower()
+            if choice in ['yes', 'y']:
+                try:
+                    subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+                    print(f"   '{package_name}' successfully installed\n")
+                except subprocess.CalledProcessError:
+                    print(f"    Failed to install '{package_name}'. Please install manually.")
+                    sys.exit(1)
+            else:
+                print(f"   Cannot continue without '{package_name}'. Exiting.")
+                sys.exit(1)

yougotmapped-1.0.0/yougotmapped/utils/mapping.py

@@ -0,0 +1,66 @@
+# utils/mapping.py
+import folium
+
+def plot_ip_location(ip_data, color='red', map_object=None):
+    if 'loc' not in ip_data:
+        print("Location data not available.")
+        return
+
+    latitude, longitude = map(float, ip_data['loc'].split(','))
+
+    m = map_object if map_object else folium.Map(location=[latitude, longitude], zoom_start=12)
+
+    folium.Marker(
+        [latitude, longitude],
+        popup=f"IP: {ip_data.get('ip', 'N/A')}\nCity: {ip_data.get('city', 'N/A')}\nRegion: {ip_data.get('region', 'N/A')}\nCountry: {ip_data.get('country', 'N/A')}",
+        icon=folium.Icon(color=color)
+    ).add_to(m)
+
+    folium.Circle(
+        radius=10000,
+        location=[latitude, longitude],
+        color=color,
+        fill=True,
+        fill_color=color,
+        fill_opacity=0.2,
+        popup="Approximate Area"
+    ).add_to(m)
+
+    return m
+
+
+def plot_multiple_ip_locations(ip_data_list):
+    if not ip_data_list:
+        print("No valid IP data to plot.")
+        return
+
+    center_data = next((d for d in ip_data_list if 'loc' in d), None)
+    if not center_data:
+        print("No valid location data found in input list.")
+        return
+
+    latitude, longitude = map(float, center_data['loc'].split(','))
+    m = folium.Map(location=[latitude, longitude], zoom_start=2)
+
+    for data in ip_data_list:
+        if 'loc' not in data:
+            continue
+        lat, lon = map(float, data['loc'].split(','))
+        folium.Marker(
+            [lat, lon],
+            popup=f"IP: {data.get('ip', 'N/A')}\nCity: {data.get('city', 'N/A')}\nRegion: {data.get('region', 'N/A')}\nCountry: {data.get('country', 'N/A')}",
+            icon=folium.Icon(color='red')
+        ).add_to(m)
+
+        folium.Circle(
+            radius=10000,
+            location=[lat, lon],
+            color='red',
+            fill=True,
+            fill_color='red',
+            fill_opacity=0.2,
+            popup="Approximate Area"
+        ).add_to(m)
+
+    m.save('ip_geolocation_map.html')
+    print("Map saved with multiple IPs as 'ip_geolocation_map.html'")

yougotmapped-1.0.0/yougotmapped/utils/network.py

@@ -0,0 +1,34 @@
+# utils/network.py
+import requests
+import ipaddress
+import socket
+
+
+def get_public_ip():
+    try:
+        response = requests.get('https://api.ipify.org')
+        response.raise_for_status()
+        return response.text
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching public IP: {e}")
+        return None
+
+
+def get_geolocation(ip_or_domain, api_token):
+    url = f"https://ipinfo.io/{ip_or_domain}/json"
+    params = {'token': api_token} if api_token else {}
+    try:
+        response = requests.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching geolocation data: {e}")
+        return None
+
+
+def resolve_domain_to_ip(domain):
+    try:
+        return socket.gethostbyname(domain)
+    except socket.gaierror:
+        print(f"Could not resolve domain: {domain}")
+        return None

yougotmapped-1.0.0/yougotmapped/utils/output.py

@@ -0,0 +1,67 @@
+# utils/output.py
+import json
+import csv
+from io import StringIO
+
+
+def format_as_normal(data):
+    output = []
+    for d in data:
+        lines = []
+        for key, value in d.items():
+            if isinstance(value, dict):
+                lines.append(f"{key.title()}:")
+                for sub_key, sub_val in value.items():
+                    lines.append(f"  {sub_key.title()}: {sub_val}")
+            else:
+                lines.append(f"{key.title()}: {value}")
+        output.append("\n".join(lines))
+        output.append("\n" + "-" * 40 + "\n")
+    return "\n".join(output)
+
+
+def flatten_for_csv(entry):
+    """
+    Flatten nested dictionaries for CSV.
+    For example: {"anonymity": {"vpn": False}} -> {"anonymity_vpn": False}
+    """
+    flat = {}
+    for key, value in entry.items():
+        if isinstance(value, dict):
+            for sub_key, sub_val in value.items():
+                flat[f"{key}_{sub_key}"] = sub_val
+        else:
+            flat[key] = value
+    return flat
+
+
+def format_as_csv(data):
+    if not data:
+        return ""
+    flat_data = [flatten_for_csv(d) for d in data]
+    # Collect all possible fields across entries
+    fieldnames = sorted({key for d in flat_data for key in d.keys()})
+    output = StringIO()
+    writer = csv.DictWriter(output, fieldnames=fieldnames)
+    writer.writeheader()
+    for d in flat_data:
+        writer.writerow(d)
+    return output.getvalue()
+
+
+def format_as_json(data):
+    return json.dumps(data, indent=4)
+
+
+def write_formatted_output(data, file_path, fmt_type="normal"):
+    fmt_type = fmt_type.lower()
+    if fmt_type == "csv":
+        formatted = format_as_csv(data)
+    elif fmt_type == "json":
+        formatted = format_as_json(data)
+    else:
+        formatted = format_as_normal(data)
+
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(formatted)
+    print(f"Output saved to {file_path} in {fmt_type.upper()} format.")

yougotmapped-1.0.0/yougotmapped/utils/ping.py

@@ -0,0 +1,56 @@
+# utils/pings.py
+from ping3 import ping
+import statistics
+
+def classify_rtt_latency(latency):
+    if latency < 1:
+        return "LAN or loopback — same machine or local router"
+    elif latency < 5:
+        return "Local network — same building or direct fiber"
+    elif latency < 20:
+        return "Nearby region — very low-latency ISP link"
+    elif latency < 50:
+        return "Fast WAN — CDN, local data center, or strong routing"
+    elif latency < 100:
+        return "Typical internet — stable ISP-to-ISP connection"
+    elif latency < 200:
+        return "Remote server — possible transcontinental routing"
+    elif latency < 400:
+        return "High latency — distant, congested, or routed via relay"
+    else:
+        return "Unstable or suspicious — VPN, proxy, or degraded network"
+
+def ping_target(host, count=4):
+    """
+    Pings the given host and returns avg latency, loss %, estimated distance, and a basic label.
+    """
+    latencies = []
+
+    for _ in range(count):
+        try:
+            delay = ping(host, timeout=1)
+            if delay:
+                latencies.append(delay)
+        except Exception:
+            continue
+
+    received = len(latencies)
+    lost = count - received
+
+    if received == 0:
+        return f"Ping to {host}: unreachable ({count} packets lost)"
+
+    avg_latency_ms = round(statistics.mean(latencies) * 1000, 2)
+    packet_loss = round((lost / count) * 100, 1)
+
+    # Go back to fast, rough RTT-based estimate: 200 km/ms
+    estimated_distance_km = round((avg_latency_ms / 2) * 200)
+    label = classify_rtt_latency(avg_latency_ms)
+
+    return (
+        f"Ping to {host} ({count} packets):\n"
+        f"  Avg Latency: {avg_latency_ms} ms\n"
+        f"  Packet Loss: {packet_loss}%\n"
+        f"  Est. Distance: ~{estimated_distance_km} km (RTT-based)\n"
+        f"  Inference: {label}"
+    )

yougotmapped-1.0.0/yougotmapped/utils/token.py

@@ -0,0 +1,31 @@
+# utils/token.py
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+def get_api_token():
+    # Force .env path to the installed package folder
+    env_path = Path(__file__).resolve().parent.parent / ".env"
+    load_dotenv(dotenv_path=env_path)
+
+    token = os.getenv("IPINFO_TOKEN")
+    if token:
+        return token
+
+    print("'IPINFO_TOKEN' environment variable not found.")
+    print("To use this tool, you need a free API token from ipinfo.io.")
+    print("Visit: https://ipinfo.io/signup")
+    token = input("Enter your IPInfo token: ").strip()
+
+    if token:
+        save = input("Would you like to save this token to a .env file for future runs? (yes/no): ").strip().lower()
+        if save in ['yes', 'y']:
+            try:
+                with open(env_path, "a") as env_file:
+                    env_file.write(f"\nIPINFO_TOKEN={token}\n")
+                print("Token saved to .env file. Make sure to load it in your script using python-dotenv or similar.")
+            except Exception as e:
+                print(f"Error saving token: {e}")
+        return token
+
+    return None

yougotmapped-1.0.0/yougotmapped/utils/trace.py

@@ -0,0 +1,70 @@
+# utils/trace.py
+import subprocess
+import platform
+import re
+import ipaddress
+from yougotmapped.utils.network import get_geolocation
+
+def run_traceroute(host, max_hops=30, timeout=60):
+    system = platform.system()
+    if system == "Windows":
+        cmd = ["tracert", "-h", str(max_hops), host]
+    elif system in ["Linux", "Darwin"]:
+        cmd = ["traceroute", "-m", str(max_hops), "-w", "1", host]
+    else:
+        return f"Traceroute not supported on {system}"
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        return format_trace_output(result.stdout)
+    except subprocess.TimeoutExpired:
+        return f"Traceroute to {host} timed out after {timeout} seconds."
+    except FileNotFoundError:
+        return f"Traceroute command not found on this system."
+    except Exception as e:
+        return f"Traceroute failed: {e}"
+
+
+def is_private_ip(ip):
+    try:
+        return ipaddress.ip_address(ip).is_private
+    except ValueError:
+        return False
+
+
+def extract_ip_latency(line):
+    ip_match = re.findall(r"(\d+\.\d+\.\d+\.\d+)", line)
+    rtt_match = re.findall(r"(\d+\.\d+) ms", line)
+    return ip_match[0] if ip_match else None, rtt_match[0] if rtt_match else None
+
+
+def format_trace_output(raw_output):
+    lines = raw_output.strip().split("\n")
+    formatted_lines = []
+    last_ip = None
+
+    for index, line in enumerate(lines):
+        ip, rtt = extract_ip_latency(line)
+        if not ip:
+            continue
+
+        label = "(Private)" if is_private_ip(ip) else extract_label(line)
+        formatted_lines.append(f"[{index+1}] {ip.ljust(18)} {label.ljust(30)} {rtt} ms")
+        last_ip = ip
+
+    # Append final geolocation if last IP is public
+    if last_ip and not is_private_ip(last_ip):
+        data = get_geolocation(last_ip, None)
+        if data:
+            geo_info = f"  --> {data.get('city', 'N/A')}, {data.get('region', '')} ({data.get('org', 'N/A')})"
+            formatted_lines.append(geo_info)
+
+    return "\n".join(formatted_lines)
+
+
+def extract_label(line):
+    parts = line.split()
+    for part in parts:
+        if any(ext in part for ext in [".com", ".net", ".org"]):
+            return f"({part})"
+    return "(Public)"

yougotmapped-1.0.0/yougotmapped.egg-info/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: yougotmapped
+Version: 1.0.0
+Summary: A terminal tool to map IPs and domains with style.
+Home-page: https://github.com/diputs-sudo/YouGotMapped
+Author: diputs
+Author-email: diputs-sudo@proton.me
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: folium
+Requires-Dist: python-dotenv
+Requires-Dist: ping3
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🌍 YouGotMapped — IP Geolocation Mapper
+
+Ever wondered where that weird IP pinging your router is *actually* from? 
+Or maybe you're just nosy (respect). Either way — this script's for you.
+
+**YouGotMapped** is a sassy little Python tool that:
+- Auto-fetches your IP (if you dare expose yourself)
+- Accepts any domain or IP you throw at it
+- Contacts the internet (politely) for geo intel
+- Drops a sweet, interactive map
+
+---
+
+## ✨ Features
+
+- Lookup **IP addresses** or **domains** like a pro hacker wannabe
+- Detects your public IP like "hi, it's me"
+- Maps exact-ish coordinates using [ipinfo.io](https://ipinfo.io)
+- Generates a **live HTML map** with red circle vibes
+- Dependency check? Yup — it acts like a cool installer
+- Quietly avoids private IPs (don’t be that guy)
+- Clean, modular CLI with argparse support
+
+---
+
+## 🛠️ Requirements
+
+- Python 3.7+
+- Packages: `requests`, `folium`, ... (or let the script install it for you!)
+- A totally-free `IPINFO_TOKEN` (get it [here](https://ipinfo.io/signup))
+
+---
+
+## 🚀 Run It Like a Legend
+
+use pip !
+
+```bash
+pip install yougotmapped
+```
+
+```bash
+# Clone the repo
+git clone https://github.com/Zynk-dot/YouGotMapped.git
+cd YouGotMapped
+
+# Option 1: Set token temporarily
+export IPINFO_TOKEN=your_ipinfo_token
+
+# Option 2: Let the script prompt you and save it to .env
+
+# Run the thing
+$ python3 yougotmapped.py
+```
+
+Then follow the prompts like a civilized hacker. You can:
+- Press Enter to map **your own IP** (hello, paranoia)
+- Or enter someone else's... 👀 (just be cool about it)
+
+---
+
+## 🧪 What You Get
+
+- A readout of city, region, country, and more
+- A *Google Maps-esque* HTML file you can open in your browser
+- Optional delete at the end (for sneaky folks)
+
+**File:** `ip_geolocation_map.html`
+
+You can keep it. Frame it. Or trash it like a spy after a mission.
+
+---
+
+## 🔐 Security Hints
+
+- We only send your query to **ipinfo.io** — no creepy business
+- Private IPs are blocked because that’s just weird
+- API token is pulled from env vars (no hardcoded sins here)
+
+---
+
+## 🙋 Who Made This?
+
+> Created by a ghost.   
+> No name, no trace, no problem.
+
+Contact? Nah, we don’t do that here.    
+If it breaks, fix it yourself — you're clearly smart enough to run this.    
+
+---
+
+## ⭐ Why Star This Repo?
+
+Because it's:
+- Actually useful
+- Small but mighty
+- Funny
+- And you’re already here reading this — go on, click ⭐
+
+> This repo was cloned 30+ times before it even had a README. That’s how you know it slaps.
+
+Thanks for checking this out.
+You got mapped! 🗺️

yougotmapped-1.0.0/yougotmapped.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+yougotmapped/__init__.py
+yougotmapped/cli.py
+yougotmapped.egg-info/PKG-INFO
+yougotmapped.egg-info/SOURCES.txt
+yougotmapped.egg-info/dependency_links.txt
+yougotmapped.egg-info/entry_points.txt
+yougotmapped.egg-info/requires.txt
+yougotmapped.egg-info/top_level.txt
+yougotmapped/utils/__init__.py
+yougotmapped/utils/anonymity.py
+yougotmapped/utils/dependencies.py
+yougotmapped/utils/mapping.py
+yougotmapped/utils/network.py
+yougotmapped/utils/output.py
+yougotmapped/utils/ping.py
+yougotmapped/utils/token.py
+yougotmapped/utils/trace.py

yougotmapped-1.0.0/yougotmapped.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yougotmapped-1.0.0/yougotmapped.egg-info/entry_points.txt

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

yougotmapped-1.0.0/yougotmapped.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests
+folium
+python-dotenv
+ping3

yougotmapped-1.0.0/yougotmapped.egg-info/top_level.txt

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