A!leys Galerie

import os
import json
import pytesseract
from PIL import Image
from datetime import datetime
import glob
import uuid
import platform
import sqlite3
from typing import List, Dict, Optional, Tuple
import pathlib
import base64

# Set the path to tesseract executable if not in PATH
# pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

class ScreenshotOrganizer:
    """
    A class to organize screenshots based on OCR content and store metadata in a local database.
    """

    def __init__(self, db_path: str = "screenshot_organizer.db"):
        self.db_path = db_path
        self._init_db()

    def _init_db(self) -> None:
        """Initialize the database with necessary tables."""
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS metadata (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    file_path TEXT NOT NULL,
                    file_name TEXT NOT NULL,
                    ocr_content TEXT,
                    timestamp DATETIME,
                    category TEXT,
                    uuid TEXT UNIQUE
                )
            """)
            conn.commit()

    def _extract_ocr(self, image_path: str) -> str:
        """Extract text from an image using OCR."""
        try:
            img = Image.open(image_path)
            text = pytesseract.image_to_string(img)
            return text.strip()
        except Exception as e:
            print(f"Error extracting OCR from {image_path}: {e}")
            return ""

    def _categorize(self, ocr_content: str) -> str:
        """Categorize the OCR content based on keywords."""
        ocr_content = ocr_content.lower()
        if "invoice" in ocr_content or "rechnung" in ocr_content:
            return "Invoice"
        elif "contract" in ocr_content or "vertrag" in ocr_content:
            return "Contract"
        elif "password" in ocr_content or "secret" in ocr_content:
            return "Password"
        elif "meeting" in ocr_content or "agenda" in ocr_content:
            return "Meeting"
        else:
            return "Other"

    def _save_metadata(self, file_path: str, ocr_content: str, category: str) -> None:
        """Save metadata to the database."""
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute("""
                INSERT INTO metadata (file_path, file_name, ocr_content, timestamp, category, uuid)
                VALUES (?, ?, ?, ?, ?, ?)
            """, (file_path, os.path.basename(file_path), ocr_content, datetime.now().isoformat(), category, str(uuid.uuid4())))
            conn.commit()

    def _move_file(self, src_path: str, dest_path: str) -> Optional[str]:
        """Move the file to the destination directory."""
        try:
            os.makedirs(dest_path, exist_ok=True)
            new_file_name = f"{uuid.uuid4().hex}_{os.path.basename(src_path)}"
            new_file_path = os.path.join(dest_path, new_file_name)
            os.rename(src_path, new_file_path)
            return new_file_name
        except Exception as e:
            print(f"Error moving file {src_path}: {e}")
            return None

    def process_directory(self, directory: str) -> None:
        """Process all images in the specified directory."""
        if not os.path.isdir(directory):
            print(f"Directory {directory} does not exist.")
            return

        files = glob.glob(os.path.join(directory, "*.jpg")) + glob.glob(os.path.join(directory, "*.png")) + glob.glob(os.path.join(directory, "*.jpeg"))

        for file_path in files:
            if os.path.basename(file_path).startswith("."):
                continue

            print(f"Processing {file_path}...")
            ocr_content = self._extract_ocr(file_path)
            category = self._categorize(ocr_content)
            new_file_name = self._move_file(file_path, os.path.join(directory, category))

            if new_file_name:
                self._save_metadata(file_path, ocr_content, category)
                print(f"Moved {file_path} to {os.path.join(directory, category)} and saved metadata.")

    def save_state(self, path: str = "screenshot_organizer_state.json") -> None:
        """Save the current state to a JSON file."""
        try:
            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute("SELECT * FROM metadata")
                rows = cursor.fetchall()

                state = {
                    "metadata": [dict(zip([column[0] for column in cursor.description], row)) for row in rows],
                    "timestamp": datetime.now().isoformat()
                }

                with open(path, "w") as f:
                    json.dump(state, f, indent=4)
        except Exception as e:
            print(f"Error saving state: {e}")

    def load_state(self, path: str = "screenshot_organizer_state.json") -> bool:
        """Load the state from a JSON file."""
        try:
            if not os.path.exists(path):
                return False

            with open(path, "r") as f:
                state = json.load(f)

            with sqlite3.connect(self.db_path) as conn:
                cursor = conn.cursor()
                cursor.execute("DELETE FROM metadata")
                for row in state["metadata"]:
                    cursor.execute("""
                        INSERT INTO metadata (file_path, file_name, ocr_content, timestamp, category, uuid)
                        VALUES (?, ?, ?, ?, ?, ?)
                    """, (row["file_path"], row["file_name"], row["ocr_content"], row["timestamp"], row["category"], row["uuid"]))
                conn.commit()

            return True
        except Exception as e:
            print(f"Error loading state: {e}")
            return False

def main():
    import argparse

    parser = argparse.ArgumentParser(description="Organize screenshots based on OCR content.")
    parser.add_argument("directory", help="Directory containing the screenshots to process")
    parser.add_argument("--save-state", action="store_true", help="Save the current state to a JSON file")
    parser.add_argument("--load-state", action="store_true", help="Load the state from a JSON file")

    args = parser.parse_args()

    organizer = ScreenshotOrganizer()

    if args.load_state:
        if organizer.load_state():
            print("State loaded successfully.")
        else:
            print("State file not found or could not be loaded.")

    organizer.process_directory(args.directory)

    if args.save_state:
        organizer.save_state()
        print("State saved successfully.")

if __name__ == "__main__":
    main()

using UnityEngine;
using System.IO;
using System.Collections.Generic;
using UnityEngine.UI;
using System.Linq;

[System.Serializable]
public class CreativeDataPackage
{
    public string packageName;
    public List<Vector3> points;
    public Color primaryColor;
    public float rotationSpeed;
    public bool isBouncy;
    public List<string> funFacts;
}

public class AileyJsonSerializer : MonoBehaviour
{
    [SerializeField] private GameObject _prefabToInstantiate;
    [SerializeField] private Transform _spawnContainer;
    [SerializeField] private Text _uiStatusText;
    [SerializeField] private float _minDistance = 0.5f;
    [SerializeField] private float _maxDistance = 10f;
    [SerializeField] private float _minSpeed = 1f;
    [SerializeField] private float _maxSpeed = 5f;

    private List<CreativeDataPackage> _savedPackages = new List<CreativeDataPackage>();
    private int _currentPackageIndex = -1;
    private GameObject _activeObject;
    private float _timeSinceLastInput = 0f;
    private const float _inputCooldown = 0.5f;

    private void Awake()
    {
        if (_spawnContainer == null)
        {
            _spawnContainer = new GameObject("SpawnContainer").transform;
            _spawnContainer.SetParent(transform);
        }

        if (_uiStatusText == null)
        {
            Debug.LogWarning("UI Status Text not assigned. Creating a temporary one.");
            CreateTemporaryUI();
        }

        LoadAllPackages();
    }

    private void CreateTemporaryUI()
    {
        GameObject uiPanel = new GameObject("UIPanel");
        uiPanel.transform.SetParent(transform);
        RectTransform rect = uiPanel.AddComponent<RectTransform>();
        rect.sizeDelta = new Vector2(400, 200);

        _uiStatusText = uiPanel.AddComponent<Text>();
        _uiStatusText.text = "No packages loaded. Press S to save, L to load.";
        _uiStatusText.font = Resources.GetBuiltinResource<Font>("Arial.ttf");
        _uiStatusText.color = Color.white;
        _uiStatusText.alignment = TextAnchor.UpperLeft;
    }

    private void Update()
    {
        _timeSinceLastInput += Time.deltaTime;

        // Handle keyboard shortcuts
        if (Input.GetKeyDown(KeyCode.S))
        {
            SaveCurrentPackage();
        }
        else if (Input.GetKeyDown(KeyCode.L))
        {
            LoadNextPackage();
        }
        else if (Input.GetKeyDown(KeyCode.N))
        {
            LoadPreviousPackage();
        }
        else if (Input.GetKeyDown(KeyCode.R))
        {
            ResetActiveObject();
        }
        else if (Input.GetKeyDown(KeyCode.F))
        {
            SpawnFunFact();
        }

        // Handle continuous movement if object is active
        if (_activeObject != null && _timeSinceLastInput > _inputCooldown)
        {
            MoveActiveObject();
        }
    }

    private void SaveCurrentPackage()
    {
        if (_activeObject != null)
        {
            CreativeDataPackage data = new CreativeDataPackage
            {
                packageName = "Package_" + System.DateTime.Now.ToString("yyyyMMdd_HHmmss"),
                points = GetObjectPoints(_activeObject),
                primaryColor = _activeObject.GetComponent<Renderer>().material.color,
                rotationSpeed = Random.Range(1f, 10f),
                isBouncy = Random.value > 0.5f,
                funFacts = GenerateFunFacts()
            };

            _savedPackages.Add(data);
            SavePackageToJson(data);
            _uiStatusText.text = $"Saved: {data.packageName} (Total: {_savedPackages.Count})";
        }
        else
        {
            _uiStatusText.text = "No active object to save!";
        }
    }

    private List<Vector3> GetObjectPoints(GameObject obj)
    {
        List<Vector3> points = new List<Vector3>();
        MeshFilter meshFilter = obj.GetComponent<MeshFilter>();
        if (meshFilter != null && meshFilter.mesh != null)
        {
            Vector3[] vertices = meshFilter.mesh.vertices;
            for (int i = 0; i < vertices.Length; i += 2) // Sample every 2 vertices for performance
            {
                Vector3 worldPoint = obj.transform.TransformPoint(vertices[i]);
                points.Add(worldPoint);
            }
        }
        return points;
    }

    private void LoadNextPackage()
    {
        if (_savedPackages.Count == 0)
        {
            _uiStatusText.text = "No packages to load!";
            return;
        }

        _currentPackageIndex = (_currentPackageIndex + 1) % _savedPackages.Count;
        LoadPackage(_savedPackages[_currentPackageIndex]);
    }

    private void LoadPreviousPackage()
    {
        if (_savedPackages.Count == 0)
        {
            _uiStatusText.text = "No packages to load!";
            return;
        }

        _currentPackageIndex = (_currentPackageIndex - 1 + _savedPackages.Count) % _savedPackages.Count;
        LoadPackage(_savedPackages[_currentPackageIndex]);
    }

    private void LoadPackage(CreativeDataPackage data)
    {
        if (_activeObject != null)
        {
            Destroy(_activeObject);
        }

        _activeObject = Instantiate(_prefabToInstantiate, _spawnContainer);
        _activeObject.transform.localPosition = Vector3.zero;

        // Apply data
        Renderer renderer = _activeObject.GetComponent<Renderer>();
        if (renderer != null)
        {
            renderer.material.color = data.primaryColor;
        }

        Rigidbody rb = _activeObject.GetComponent<Rigidbody>();
        if (rb != null)
        {
            rb.angularVelocity = Random.insideUnitSphere * data.rotationSpeed;
            rb.isKinematic = !data.isBouncy;
        }

        // Spawn points as child spheres
        foreach (Vector3 point in data.points)
        {
            GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
            sphere.transform.SetParent(_activeObject.transform);
            sphere.transform.localPosition = point;
            sphere.transform.localScale = Vector3.one * 0.1f;
            sphere.GetComponent<Renderer>().material.color = data.primaryColor;
        }

        _uiStatusText.text = $"Loaded: {data.packageName} (Index: {_currentPackageIndex + 1}/{_savedPackages.Count})";
        _timeSinceLastInput = 0f;
    }

    private void SavePackageToJson(CreativeDataPackage data)
    {
        string json = JsonUtility.ToJson(data, true);
        string path = Path.Combine(Application.persistentDataPath, $"{data.packageName}.json");

        try
        {
            File.WriteAllText(path, json);
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Failed to save package: {e.Message}");
            _uiStatusText.text = $"Failed to save: {e.Message}";
        }
    }

    private void LoadAllPackages()
    {
        string path = Application.persistentDataPath;
        if (!Directory.Exists(path))
        {
            Directory.CreateDirectory(path);
        }

        string[] jsonFiles = Directory.GetFiles(path, "*.json");
        foreach (string file in jsonFiles)
        {
            try
            {
                string json = File.ReadAllText(file);
                CreativeDataPackage data = JsonUtility.FromJson<CreativeDataPackage>(json);
                _savedPackages.Add(data);
                _uiStatusText.text = $"Loaded {_savedPackages.Count} packages from disk";
            }
            catch (System.Exception e)
            {
                Debug.LogWarning($"Failed to load {file}: {e.Message}");
            }
        }
    }

    private void ResetActiveObject()
    {
        if (_activeObject != null)
        {
            _activeObject.transform.localPosition = Vector3.zero;
            _activeObject.transform.rotation = Quaternion.identity;
            Rigidbody rb = _activeObject.GetComponent<Rigidbody>();
            if (rb != null)
            {
                rb.angularVelocity = Vector3.zero;
                rb.velocity = Vector3.zero;
            }
            _uiStatusText.text = "Object reset!";
            _timeSinceLastInput = 0f;
        }
    }

    private void MoveActiveObject()
    {
        if (_activeObject != null)
        {
            float horizontal = Input.GetAxis("Horizontal");
            float vertical = Input.GetAxis("Vertical");

            if (Mathf.Abs(horizontal) > 0.1f || Mathf.Abs(vertical) > 0.1f)
            {
                _timeSinceLastInput = 0f;
                Vector3 movement = new Vector3(horizontal, 0f, vertical) * _activeObject.GetComponent<Rigidbody>().mass * 0.1f;
                _activeObject.transform.position += movement;

                // Add some randomness to make it more fun
                if (Random.value > 0.7f)
                {
                    _activeObject.transform.position += new Vector3(
                        Random.Range(-0.5f, 0.5f),
                        Random.Range(-0.5f, 0.5f),
                        Random.Range(-0.5f, 0.5f)
                    );
                }
            }
        }
    }

    private List<string> GenerateFunFacts()
    {
        List<string> facts = new List<string>
        {
            "Did you know that bees can recognize human faces?",
            "A day on Venus is longer than a year on Venus.",
            "The shortest war in history was between Britain and Zanzibar in 1896. It lasted 38 minutes.",
            "Honey never spoils. Archaeologists have found pots of honey in ancient Egyptian tombs that are over 3,000 years old and still perfectly edible.",
            "Your stomach produces enough acid in one day to dissolve a razors blade.",
            "Octopuses have three hearts: two pump blood to the gills, and one pumps it to the rest of the body.",
            "The word 'lethargy' comes from the Greek word for forgetfulness.",
            "A group of flamingos is called a 'flamboyance'.",
            "The longest place name in the world is in New Zealand: Tē Tarāwhaiātoaterāpokakapakikahaumangakāpukakapopōtōtū (85 letters).",
            "Bananas are berries, but strawberries aren't."
        };

        return facts.OrderBy(x => Random.Range(0, 100)).Take(3).ToList();
    }

    private void SpawnFunFact()
    {
        if (_savedPackages.Count == 0 || _currentPackageIndex < 0)
        {
            _uiStatusText.text = "No package loaded to spawn facts!";
            return;
        }

        List<string> facts = _savedPackages[_currentPackageIndex].funFacts;
        if (facts.Count > 0)
        {
            string fact = facts[Random.Range(0, facts.Count)];
            _uiStatusText.text = $"Fun Fact: {fact}";
        }
    }

    #region Editor Methods (For Unity Inspector)
#if UNITY_EDITOR
    private void Reset()
    {
        if (_spawnContainer == null)
        {
            _spawnContainer = new GameObject("SpawnContainer").transform;
            _spawnContainer.SetParent(transform);
        }
    }
#endif
    #endregion
}