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()