Бот для автовыполнения задач

import os
import random
import time
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
 
# === Settings ===
API_KEY = ""  # Insert your Google Maps API key
LOCATIONS = ["Москва"]  # Main places
NEARBY_TYPES = ["park", "street", "store", "office", "factory", "restaurant", "cafe", "gas_station"]  # Types of places
RECONNECT_INTERVAL = 5
PROFILE_PATH = os.path.expanduser("~/.config/google-chrome/Default")  # Path to Chrome profile
LOG_FILE = "activity_log.txt"  # Log file for actions
 
# === Functions ===
def check_internet():
    """Checks internet connectivity."""
    try:
        requests.get('http://www.google.com', timeout=3)
        return True
    except requests.ConnectionError:
        return False
 
def setup_browser():
    """Configures the Chrome browser."""
    options = Options()
    options.add_argument(f"--user-data-dir={PROFILE_PATH}")  # Use your Chrome profile
    options.add_argument("--disable-blink-features=AutomationControlled")
    options.add_argument("--start-maximized")
    return webdriver.Chrome(service=Service("/usr/bin/chromedriver"), options=options)
 
def type_text_slowly(search_box, text):
    """Simulates slow typing of text."""
    for char in text:
        search_box.send_keys(char)
        time.sleep(random.uniform(0.1, 0.3))  # Delay between characters
 
def log_action(action):
    """Logs actions to a file."""
    with open(LOG_FILE, "a") as log_file:
        log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - {action}\n")
 
def zoom_in_out(driver):
    """Simulates zooming in and out on the map."""
    try:
        # Zoom in
        for _ in range(2):
            driver.find_element(By.CSS_SELECTOR, "button[aria-label='Увеличить масштаб']").click()
            time.sleep(random.uniform(1, 2))
        log_action("Zoomed in twice")
 
        # Zoom out
        for _ in range(2):
            driver.find_element(By.CSS_SELECTOR, "button[aria-label='Уменьшить масштаб']").click()
            time.sleep(random.uniform(1, 2))
        log_action("Zoomed out twice")
    except Exception as e:
        log_action(f"Error during zoom in/out: {e}")
 
def find_nearby_places(lat, lon):
    """Finds places near specified coordinates."""
    nearby_results = []
    for place_type in NEARBY_TYPES:
        url = (f"https://maps.googleapis.com/maps/api/place/nearbysearch/json?"
               f"location={lat},{lon}&radius=1500&type={place_type}&key={API_KEY}")
        response = requests.get(url)
        if response.status_code == 200:
            results = response.json().get("results", [])
            for place in results:
                name = place.get("name", "Без имени")
                address = place.get("vicinity", "Адрес отсутствует")
                rating = place.get("rating", "Рейтинг отсутствует")
                nearby_results.append(f"{place_type.capitalize()} - {name}: {address} (Рейтинг: {rating})")
    return nearby_results
 
def simulate_movement():
    """Simulates text-based queries on Google Maps."""
    driver = setup_browser()
    try:
        # Open Google Maps
        driver.get("https://www.google.com/maps")
        print("Google Maps opened.")
 
        wait = WebDriverWait(driver, 10)
        for location in LOCATIONS:
            print(f"Searching for: {location}")
            log_action(f"Search: {location}")
 
            # Find the input box and type the query
            search_box = wait.until(EC.presence_of_element_located((By.ID, "searchboxinput")))
            search_box.clear()
            type_text_slowly(search_box, location)  # Simulate slow typing
            search_box.send_keys(Keys.RETURN)
            time.sleep(5)  # Wait for results to load
 
            # Simulate zooming in and out
            zoom_in_out(driver)
 
            # Simulate interaction with objects
            lat, lon = 50.4501, 30.5234  # Use API to get coordinates
            nearby_places = find_nearby_places(lat, lon)
            for place in nearby_places:
                print(place)
                log_action(place)
 
            # Delay before the next query
            time.sleep(random.randint(10, 20))
 
    except Exception as e:
        print(f"Error: {e}")
        log_action(f"Error: {e}")
    finally:
        driver.quit()
        print("Browser closed.")
 
# === Main Execution ===
if __name__ == "__main__":
    simulate_movement()

import os
import random
import time
import logging
from typing import List, Dict
import googlemaps  # Официальная библиотека Google Maps
 
# Настройки логирования
logging.basicConfig(
    filename='map_research.log', 
    level=logging.INFO, 
    format='%(asctime)s - %(message)s'
)
 
class MapResearcher:
    def __init__(self, api_key: str):
        """Инициализация исследователя карт с официальной библиотекой"""
        self.client = googlemaps.Client(key=api_key)
        self.locations = ["Москва", "Санкт-Петербург"]
        self.place_types = [
            "park", "museum", "library", 
            "restaurant", "university"
        ]
 
    def find_nearby_places(self, location: str) -> List[Dict]:
        """Поиск мест с использованием официального API"""
        try:
            # Геокодирование локации
            geocode_result = self.client.geocode(location)
            if not geocode_result:
                logging.error(f"Не удалось найти координаты для {location}")
                return []
 
            lat = geocode_result[0]['geometry']['location']['lat']
            lng = geocode_result[0]['geometry']['location']['lng']
 
            # Результаты для разных типов мест
            all_places = []
            for place_type in self.place_types:
                places = self.client.places_nearby(
                    location=(lat, lng),
                    radius=5000,  # 5 км
                    type=place_type
                )
                
                for place in places.get('results', []):
                    all_places.append({
                        'name': place.get('name', 'Без названия'),
                        'address': place.get('vicinity', 'Адрес не указан'),
                        'rating': place.get('rating', 'Нет рейтинга'),
                        'type': place_type
                    })
                
                # Задержка между запросами для корректности
                time.sleep(random.uniform(0.5, 1.5))
 
            return all_places
 
        except Exception as e:
            logging.error(f"Ошибка при поиске мест: {e}")
            return []
 
    def research_locations(self):
        """Исследование локаций"""
        for location in self.locations:
            logging.info(f"Исследование локации: {location}")
            nearby_places = self.find_nearby_places(location)
            
            # Вывод и логирование результатов
            for place in nearby_places[:10]:  # Ограничение вывода
                print(f"Тип: {place['type']}")
                print(f"Название: {place['name']}")
                print(f"Адрес: {place['address']}")
                print(f"Рейтинг: {place['rating']}")
                print("-" * 30)
 
def main():
    # Используйте реальный API-ключ из Google Cloud Console
    API_KEY = "YOUR_ACTUAL_GOOGLE_MAPS_API_KEY"
    
    try:
        researcher = MapResearcher(API_KEY)
        researcher.research_locations()
    except Exception as e:
        logging.error(f"Критическая ошибка: {e}")
 
if __name__ == "__main__":
    main()