import os
import sqlite3
import datetime
import requests
from bs4 import BeautifulSoup
import shutil
# Locația tipică pentru istoricul Edge (Windows)
edge_history_path = os.path.expanduser(
r"~\\AppData\\Local\\Microsoft\\Edge\\User Data\\Default\\History"
)
# Copiem fișierul History în folderul curent
def copy_history_file(src_path, dst_name="edge_history_copy.db"):
if not os.path.exists(src_path):
print("Nu am găsit istoricul Edge.")
return None
dst_path = os.path.join(os.getcwd(), dst_name)
try:
shutil.copy(src_path, dst_path)
print(f"Am copiat baza de date în {dst_path}")
return dst_path
except Exception as e:
print(f"Eroare la copiere: {e}")
return None
def extract_copilot_links(db_path):
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
cursor.execute("""
SELECT url, title, last_visit_time
FROM urls
WHERE url LIKE '%copilot%'
""")
results = []
for url, title, last_visit_time in cursor.fetchall():
ts = datetime.datetime(1601, 1, 1) + datetime.timedelta(microseconds=last_visit_time)
results.append({
"url": url,
"title": title,
"last_visit": ts.strftime("%Y-%m-%d %H:%M:%S")
})
conn.close()
return results
def fetch_conversation(url):
try:
resp = requests.get(url)
if resp.status_code == 200:
soup = BeautifulSoup(resp.text, "html.parser")
texts = soup.get_text(separator="\n", strip=True)
return texts
else:
return f"Eroare acces {url}: {resp.status_code}"
except Exception as e:
return f"Eroare acces {url}: {e}"
if __name__ == "__main__":
copy_path = copy_history_file(edge_history_path)
if copy_path:
chats = extract_copilot_links(copy_path)
if chats:
with open("copilot_conversations.txt", "w", encoding="utf-8") as f:
for chat in chats:
content = fetch_conversation(chat["url"])
f.write(f"=== Conversație: {chat['title']} ({chat['last_visit']}) ===\n")
f.write(content)
f.write("\n\n")
print("Am salvat conversațiile în copilot_conversations.txt")
else:
print("Nu am găsit conversații Copilot în istoricul Edge.")
class RangeSlider(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self._min, self._max = 0, 1000
self._start, self._end = 0, 1000
self._dragging = None
self.setMinimumHeight(24)
def setRange(self, minimum, maximum):
self._min, self._max = minimum, maximum
self._start, self._end = minimum, maximum
self.update()
def setStart(self, val):
self._start = max(self._min, min(val, self._end))
self.update()
def setEnd(self, val):
self._end = min(self._max, max(val, self._start))
self.update()
def start(self): return self._start
def end(self): return self._end
def _pos_to_val(self, x):
w = self.width()
ratio = max(0, min(x, w)) / w if w else 0
return int(self._min + ratio*(self._max-self._min))
def _val_to_pos(self, val):
w = self.width()
return int((val-self._min)/(self._max-self._min)*w) if self._max>self._min else 0
def mousePressEvent(self, e):
x = e.position().x()
sx, ex = self._val_to_pos(self._start), self._val_to_pos(self._end)
self._dragging = "start" if abs(x-sx)<abs(x-ex) else "end"
self.mouseMoveEvent(e)
def mouseMoveEvent(self, e):
if self._dragging:
val = self._pos_to_val(int(e.position().x()))
if self._dragging=="start": self.setStart(val)
else: self.setEnd(val)
def mouseReleaseEvent(self,e): self._dragging=None
def paintEvent(self,e):
p=QPainter(self); rect=self.rect()
sx,ex=self._val_to_pos(self._start),self._val_to_pos(self._end)
p.fillRect(rect,QColor(220,220,220))
p.fillRect(QRect(QPoint(sx,0),QPoint(ex,rect.height())),QColor(100,200,100,120))
p.setBrush(QColor(50,120,200)); p.setPen(Qt.PenStyle.NoPen)
p.drawEllipse(QPoint(sx,rect.center().y()),6,6)
p.drawEllipse(QPoint(ex,rect.center().y()),6,6)
pip install playwright
playwright installimport asyncio
from playwright.async_api import async_playwright
async def main():
async with async_playwright() as p:
browser = await p.firefox.launch(headless=False)
context = await browser.new_context()
page = await context.new_page()
await page.goto("https://www.google.com")
queries = [
"python automation",
"playwright tutorial",
"google search automation"
]
with open("results.txt", "w", encoding="utf-8") as f:
for q in queries:
# Fill search box
await page.fill("textarea[name='q']", q)
await page.press("textarea[name='q']", "Enter")
await page.wait_for_load_state("domcontentloaded")
# Scroll + pause
await page.evaluate("window.scrollBy(0, document.body.scrollHeight)")
await page.wait_for_timeout(3000)
# Extract search results (titles + links)
results = await page.query_selector_all("h3")
f.write(f"\nResults for: {q}\n")
for r in results[:5]: # primele 5 rezultate
title = await r.inner_text()
link_el = await r.evaluate_handle("node => node.parentElement")
link = await link_el.get_attribute("href")
f.write(f"- {title} ({link})\n")
print(f"Saved results for: {q}")
await browser.close()
asyncio.run(main())
python google_search_test_001.py
Saved results for: python automation
Saved results for: playwright tutorial
Saved results for: google search automation
Results for: python automation
Results for: playwright tutorial
- Playwright: Fast and reliable end-to-end testing for modern ... python -m pip install 'xonsh[full]'
pip install mitmproxy# addon.py
from mitmproxy import http
from mitmproxy import ctx
import re
BLOCKED_HOSTS = {
"hyte.com",
"ads.example.org",
}
REWRITE_RULES = [
# Each rule: (pattern, replacement, content_type_substring)
(re.compile(rb"Hello World"), b"Salut lume", "text/html"),
(re.compile(rb"tracking", re.IGNORECASE), b"observare", "text"),
]
ADD_HEADERS = {
"X-Debug-Proxy": "mitm",
"X-George-Tool": "true",
}
class GeorgeProxy:
def __init__(self):
self.rewrite_count = 0
def load(self, loader):
ctx.log.info("GeorgeProxy addon loaded.")
def request(self, flow: http.HTTPFlow):
# Block specific hosts early
host = flow.request.host
if host in BLOCKED_HOSTS:
flow.response = http.Response.make(
403,
b"Blocked by GeorgeProxy",
{"Content-Type": "text/plain"}
)
ctx.log.warn(f"Blocked request to {host}")
return
# Add custom headers to outgoing requests
for k, v in ADD_HEADERS.items():
flow.request.headers[k] = v
ctx.log.info(f"REQ {flow.request.method} {flow.request.url}")
def response(self, flow: http.HTTPFlow):
# Only process text-like contents
ctype = flow.response.headers.get("Content-Type", "").lower()
raw = flow.response.raw_content
if raw and any(t in ctype for t in ["text", "html", "json"]):
new_content = raw
for pattern, repl, t in REWRITE_RULES:
if t in ctype:
new_content, n = pattern.subn(repl, new_content)
self.rewrite_count += n
if new_content != raw:
flow.response.raw_content = new_content
# Update Content-Length only if present
if "Content-Length" in flow.response.headers:
flow.response.headers["Content-Length"] = str(len(new_content))
ctx.log.info(f"Rewrote content ({ctype}); total matches: {self.rewrite_count}")
ctx.log.info(f"RESP {flow.response.status_code} {flow.request.url}")
addons = [GeorgeProxy()]mitmdump -s addon.py
[21:46:04.435] Loading script addon.py
[21:46:04.504] GeorgeProxy addon loaded.
[21:46:04.506] HTTP(S) proxy listening at *:8080.
[21:46:18.547][127.0.0.1:52128] client connect
[21:46:18.593] REQ GET http://httpbin.org/get
[21:46:18.768][127.0.0.1:52128] server connect httpbin.org:80 (52.44.182.178:80)
[21:46:18.910] RESP 200 http://httpbin.org/get
127.0.0.1:52128: GET http://httpbin.org/get
<< 200 OK 353b
[21:46:19.019][127.0.0.1:52128] client disconnect
[21:46:19.021][127.0.0.1:52128] server disconnect httpbin.org:80 (52.44.182.178:80)curl -x http://127.0.0.1:8080 http://httpbin.org/get
{
"args": {},
"headers": {
"Accept": "*/*",
"Host": "httpbin.org",
"Proxy-Connection": "Keep-Alive",
"User-Agent": "curl/8.13.0",
"X-Amzn-Trace-Id": "Root=1-692c9f0b-7eaf43e61f276ee62b089933",
"X-Debug-Proxy": "mitm",
"X-George-Tool": "true"
},
"origin": "84.117.220.94",
"url": "http://httpbin.org/get"
}Python Tornado – Key Capabilities
import tornado.ioloop
import tornado.web
import os
class FormHandler(tornado.web.RequestHandler):
def get(self):
self.render("form.html") # Render an HTML form
def post(self):
name = self.get_argument("name")
self.write(f"Hello, {name}!")
def make_app():
return tornado.web.Application([
(r"/form", FormHandler),
],
template_path=os.path.join(os.path.dirname(__file__), "templates") # <-- aici
)
if __name__ == "__main__":
app = make_app()
app.listen(8888)
print("Server pornit pe http://localhost:8888/form")
tornado.ioloop.IOLoop.current().start()
import os
from xai_sdk import Client
from xai_sdk.chat import user
client = Client(
api_key=os.getenv("XAI_API_KEY"),
api_host="us-east-1.api.x.ai" # Without the https://
)
chat = client.chat.create(model="grok-4")
chat.append(user("What is the meaning of life?"))
completion = chat.sample()import pymem
import pymem.process
import re
# Open the Edge process (make sure it's running)
pm = pymem.Pymem("msedge.exe")
# Get the main module of the process
module = pymem.process.module_from_name(pm.process_handle, "msedge.exe")
base = module.lpBaseOfDll
size = module.SizeOfImage
# Read the module's memory
data = pm.read_bytes(base, size)
# Search for a test pattern (generic example)
pattern = re.search(rb'\x48\x89\x5C\x24\x08\x57\x48\x83', data)
if pattern:
address = base + pattern.start()
print(f"Pattern found at: {hex(address)}")
# Read 8 bytes from the found address
raw = pm.read_bytes(address, 8)
print("Raw bytes:", raw)
# Interpret the bytes as a little-endian integer
value = int.from_bytes(raw, byteorder='little')
print("Integer value:", value)
# Write a new value (e.g., 12345678)
new_value = (12345678).to_bytes(8, byteorder='little')
pm.write_bytes(address, new_value, 8)
print("Value overwritten with 12345678.")
else:
print("Pattern not found.")
# Close the process handle
pm.close_process()
pattern = re.search(rb'\x48\x89\x5C\x24\x08\x57\x48\x83', data)
48 89 5C 24 08 → mov [rsp+8], rbx
57 → push rdi
48 83 → the start of an instruction like add/sub/cmp with a 64-bit operandpython pymem_exemple_002.py
Pattern found at: 0x7ff7180cb3d5
Raw bytes: b'H\x89\\$\x08WH\x83'
Integer value: 9459906709773125960
Value overwritten with 12345678.
import sys
import os
import shutil
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QFileDialog, QMessageBox
from PyQt6.QtCore import QDateTime
class FileRenamer(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Redenumire fișiere cu dată și index")
self.setGeometry(100, 100, 400, 150)
layout = QVBoxLayout()
self.button = QPushButton("Selectează folderul și redenumește fișierele")
self.button.clicked.connect(self.rename_files)
layout.addWidget(self.button)
self.setLayout(layout)
def rename_files(self):
folder = QFileDialog.getExistingDirectory(self, "Selectează folderul")
if not folder:
return
files = [f for f in os.listdir(folder) if os.path.isfile(os.path.join(folder, f))]
files.sort() # Sortează pentru consistență
for index, filename in enumerate(files, start=1):
old_path = os.path.join(folder, filename)
try:
creation_time = os.path.getctime(old_path)
dt = QDateTime.fromSecsSinceEpoch(int(creation_time))
date_str = dt.toString("yyyyMMdd_HHmmss")
ext = os.path.splitext(filename)[1]
new_name = f"{date_str}_{index:03d}{ext}"
new_path = os.path.join(folder, new_name)
# Evită suprascrierea fișierelor existente
if not os.path.exists(new_path):
shutil.move(old_path, new_path)
except Exception as e:
QMessageBox.critical(self, "Eroare", f"Eroare la fișierul {filename}:\n{str(e)}")
continue
QMessageBox.information(self, "Succes", "Fișierele au fost redenumite cu succes!")
if __name__ == "__main__":
app = QApplication(sys.argv)
window = FileRenamer()
window.show()
sys.exit(app.exec())
from krita import *
from PyQt5.QtWidgets import QAction, QMessageBox
import os
class ExportGodotPNG(Extension):
def __init__(self, parent):
super().__init__(parent)
def setup(self):
pass
def export_png(self):
# Get the active document
doc = Krita.instance().activeDocument()
if not doc:
QMessageBox.warning(None, "Error", "No document open! Please open a document and try again.")
return
# Create an InfoObject for PNG export
info = InfoObject()
info.setProperty("alpha", True) # Keep alpha channel for transparency
info.setProperty("compression", 0) # No compression for maximum quality
info.setProperty("interlaced", False) # Disable interlacing
info.setProperty("forceSRGB", True) # Force sRGB for Godot compatibility
# Build the output file path
if doc.fileName():
base_path = os.path.splitext(doc.fileName())[0]
else:
base_path = os.path.join(os.path.expanduser("~"), "export_godot")
output_file = base_path + "_godot.png"
# Export the document as PNG
try:
doc.exportImage(output_file, info)
# Show success message with brief usage info
QMessageBox.information(None, "Success",
f"Successfully exported as PNG for Godot: {output_file}\n\n"
"This PNG has no compression, alpha channel support, and sRGB for Godot compatibility. "
"To use in Godot, import the PNG and adjust texture settings as needed."
)
except Exception as e:
QMessageBox.critical(None, "Error", f"Export failed: {str(e)}")
def createActions(self, window):
# Create only the export action in Tools > Scripts
action_export = window.createAction("export_godot_png", "Export Godot PNG", "tools/scripts")
action_export.triggered.connect(self.export_png)
# Register the plugin
Krita.instance().addExtension(ExportGodotPNG(Krita.instance()))bl_info = {
"name": "Append Materials from Folder",
"author": "Grok",
"version": (1, 2),
"blender": (3, 0, 0),
"location": "View3D > Sidebar > Append Materials",
"description": "Select a folder and append all materials from .blend files recursively",
"category": "Import-Export",
}
import bpy
import os
from bpy.types import Operator, Panel, PropertyGroup
from bpy.props import StringProperty, PointerProperty
class AppendMaterialsProperties(PropertyGroup):
folder_path: StringProperty(
name="Folder Path",
description="Path to the folder containing .blend files",
default="",
maxlen=1024,
subtype='DIR_PATH'
)
class APPEND_OT_materials_from_folder(Operator):
bl_idname = "append.materials_from_folder"
bl_label = "Append Materials from Folder"
bl_options = {'REGISTER', 'UNDO'}
bl_description = "Append all materials from .blend files in the selected folder and subfolders"
def execute(self, context):
props = context.scene.append_materials_props
folder_path = props.folder_path
# Normalize path to avoid issues with slashes
folder_path = os.path.normpath(bpy.path.abspath(folder_path))
if not folder_path or not os.path.isdir(folder_path):
self.report({'ERROR'}, f"Invalid or no folder selected: {folder_path}")
return {'CANCELLED'}
self.report({'INFO'}, f"Scanning folder: {folder_path}")
blend_files_found = 0
materials_appended = 0
errors = []
# Walk recursively through the folder
for root, dirs, files in os.walk(folder_path):
self.report({'INFO'}, f"Checking folder: {root}")
for file in files:
if file.lower().endswith('.blend'):
blend_files_found += 1
blend_path = os.path.join(root, file)
self.report({'INFO'}, f"Found .blend file: {blend_path}")
try:
# Open the .blend file to inspect materials
with bpy.data.libraries.load(blend_path, link=False) as (data_from, data_to):
if data_from.materials:
data_to.materials = data_from.materials
materials_appended += len(data_from.materials)
self.report({'INFO'}, f"Appended {len(data_from.materials)} materials from: {blend_path}")
else:
self.report({'WARNING'}, f"No materials found in: {blend_path}")
except Exception as e:
errors.append(f"Failed to process {blend_path}: {str(e)}")
self.report({'WARNING'}, f"Error in {blend_path}: {str(e)}")
# Final report
if blend_files_found == 0:
self.report({'WARNING'}, f"No .blend files found in {folder_path} or its subfolders!")
else:
self.report({'INFO'}, f"Found {blend_files_found} .blend files, appended {materials_appended} materials.")
if errors:
self.report({'WARNING'}, f"Encountered {len(errors)} errors: {'; '.join(errors)}")
return {'FINISHED'}
class VIEW3D_PT_append_materials(Panel):
bl_space_type = 'VIEW_3D'
bl_region_type = 'UI'
bl_category = "Append Materials"
bl_label = "Append Materials from Folder"
def draw(self, context):
layout = self.layout
props = context.scene.append_materials_props
layout.prop(props, "folder_path")
layout.operator("append.materials_from_folder", text="Append Materials")
def register():
bpy.utils.register_class(AppendMaterialsProperties)
bpy.utils.register_class(APPEND_OT_materials_from_folder)
bpy.utils.register_class(VIEW3D_PT_append_materials)
bpy.types.Scene.append_materials_props = PointerProperty(type=AppendMaterialsProperties)
def unregister():
bpy.utils.unregister_class(VIEW3D_PT_append_materials)
bpy.utils.unregister_class(APPEND_OT_materials_from_folder)
bpy.utils.unregister_class(AppendMaterialsProperties)
del bpy.types.Scene.append_materials_props
if __name__ == "__main__":
register()