标签：#Python

A merge request changes one README line. The pipeline still calls a model. It costs tokens. It adds latency. It tells you almost nothing. Sound familiar? If you maintain a small CI setup, this failure keeps showing up. The instinct is to put model-based review everywhere. Then the free tier dies in a week. The fix isn't another monitor. It's a small decision gate that decides whether a diff deserves a model call at all. The operator-supplied availability claims for MonkeyCode include free model access and a free server option. I treat those claims as a starting point, not a quota guarantee. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Why every diff shouldn't hit the model Free model access is not infinite. Even if it feels free, there are hidden ceilings. Free tiers often cap requests, tokens, or time-based windows. Model output variance on trivial diffs adds noise, not signal. CI latency grows. A two-second call across a hundred merge requests is real time. The highest-value model review is rare, not constant. If you call a model on every change, you pay the full cost while getting almost none of the benefit. The gate is supposed to fix that. A three-tier escalation ladder I use a small decision table. It doesn't need to be perfect. It needs to be boring and predictable. Tier Trigger Action Model call? 0 Up to 50 added+removed lines, only docs or config suffixes, no sensitive paths Run lint and skip the model No 1 Code or test files touched, 51–400 lines, no lockfile, no migration, no sensitive path Send one bounded prompt to the free model Yes, once 2 Over 400 lines, new lockfile, migration, auth or secret paths Require human review first. Use a model only to summarize, not to decide Optional The exact numbers are arbitrary. They matter less than the fact that tier 0 never reaches the model. The code Here is a plain Python gate. It reads simple diff stats and changed paths. from pathlib import Path DOC_OR_CONFIG = { ' .md ' , '

Disclosure: This article was prepared as part of MonkeyCode's product outreach. Why this is worth reading: a free model endpoint with a large token allowance is a good place to validate a new CLI workflow, but it can burn through the allowance in a single retry loop before you notice. I built a small stateful budget guard that checks the projected cost before the call, records actual usage after the call, and refuses to touch the ledger when the endpoint sends an unexpected response. It works as a disposable first pass on a free endpoint and leaves you a clean exit when the shape changes. MonkeyCode's outreach describes an open-source project with a free model route and a free hosted server. I do not treat either as a permanent dependency. I treat them as a test target: an endpoint I can call without a contract while I am still changing prompts, timeouts, and schemas. The tool below is independent of MonkeyCode's exact model list; it assumes only an OpenAI-style chat completion path and usage accounting in the response. Swap one function if the free server does not follow that shape. The problem with a free allowance Most model dashboards report aggregate usage after the fact. That is enough for casual work, but it is not enough when you wire an endpoint into a loop. I have seen two avoidable failures in my own drafts. A retry-on-timeout wrapper restarted a slow request four times before the first response arrived, multiplying total token spend. A long context buffer kept sending the same 6k-token history on every turn because I forgot to trim old messages. The dashboard showed the total drop, but not which call caused it. A local ledger fixes that by refusing to send the request when the projected total exceeds the budget. It does not replace the provider dashboard. It makes the decision before the endpoint gets a chance to consume tokens. The artifact The script below does three jobs: load a budget and already-used amount from a JSON file make a conservative prefl

Core point: a free model tier is not a yes/no answer; it is a budget. Before I send a batch job to an advertised free tier, I want a deterministic ledger that predicts a quota miss instead of discovering it after 40 minutes. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Recent DEV threads circle around AI watermarking, agent tool gates, and whether AI is a thinking problem. My problem is smaller: I have an operator-supplied figure of 30,000,000 free tokens and a free server option , and I want to know if a batch script fits without making a single live request. Why this matters now Free tiers tend to advertise a raw allowance, but batch jobs fail in unhelpful ways: The counter jumps at the end, not before the job. A retry doubles the spend without visible feedback. System prompts, long completions, and JSON overhead count too. A tiny ledger turns that into a pass/fail fixture before any API call. The failing fixture Suppose a batch job needs 6,000 summaries where each prompt is roughly 21,000 characters. The completion target is 500 characters per call. My rough English heuristic is: 1 token ≈ 4 characters That gives 5,250 prompt tokens plus 125 completion tokens per call, so 5,375 tokens per call. Multiplied by 6,000 calls, the job would need about 32,250,000 tokens — over the 30,000,000 allowance. That is the error input. The job must fail before I spend anything. The minimal ledger Python 3.11+ is enough. No external packages. Replace the ALLOWANCE value with the limit from your own account. from dataclasses import dataclass ALLOWANCE = 30_000_000 # operator-supplied allowance, 30M tokens @dataclass ( frozen = True ) class Job : name : str prompt_chars : int completion_chars : int calls : int def estimate_tokens ( chars : int ) -> int : # Planning heuristic only: 1 English token ~= 4 characters. # A real tokenizer will differ; use it for order-of-magnitude checks. return max ( 1 , chars // 4 ) def plan_job ( job : Job , allowance

🌐 Leia a versão em português deste artigo aqui . 1. From Part One to Language Protocols In Part 1 , we established the foundation of Python's data model: objects possess identity, type, and value; names hold references to those objects; mutability determines what changes can occur without replacing the object; and containers store references to other objects. Now we advance another layer. The type of an object does not merely determine what values it can represent. It also determines which operations that object supports : whether it has a size, whether it can be traversed, compared, indexed, called as a function, used in a with statement, and so forth (PYTHON SOFTWARE FOUNDATION, 2026a). This is where special methods come in. An important observation before we continue: in Part 1 we used memory address as a mental model for identity. More rigorously, Python guarantees that an object's identity remains stable during its existence. In CPython specifically, id(obj) corresponds to the memory address of the object; this is a detail of the reference implementation, not a language guarantee (PYTHON SOFTWARE FOUNDATION, 2026a). The same distinction will be important when we discuss garbage collection and finalization: Python specifies the language's behavior; CPython is one implementation of that behavior . Reference Version The behaviors and references in this article were reviewed based on the official documentation of Python 3.14.7 . CPython-specific details will be explicitly identified. 2. What Are Special Methods In the official documentation, names like __len__ , __iter__ , and __add__ are called special methods . In the community, you will also commonly find the terms magic methods or dunder methods ( dunder comes from double underscore because of the __name__ pattern). They allow classes defined by us to participate in operations that are part of the language's own syntax and built-in functions. For example: You write Behavior Python must resolve Related methods r

I built a RAG assistant, then found out my architecture change made it worse, and I'm glad it happened I recently built a hybrid RAG (retrieval-augmented generation) support assistant for a fictional B2B SaaS platform, "Helix," designed to answer customer-success questions grounded in a 100-document knowledge base of product docs, runbooks, and resolved support tickets. It cleared production-readiness evaluation thresholds comfortably: 0.939 faithfulness and 0.775 context precision on a 50-query RAGAs test set, against required floors of 0.70 and 0.60. But the most useful thing that came out of the project wasn't the passing score. It was a hypothesis that turned out to be wrong, and what I did after finding that out. The setup The pipeline ingests a mixed-format 100-document corpus (Markdown product docs, PDF runbooks, HTML support tickets) into a Pinecone vector index, retrieves relevant context, and generates a grounded, citation-backed answer with an explicit confidence rating via an LCEL chain. Structured output is enforced with Pydantic ( answer , sources , confidence ), using gpt-4o-mini at temperature=0 , because a support assistant answering the same question against the same context should give the same answer every time. Determinism mattered more than creative variation here. Chunking wasn't one-size-fits-all. Three formats needed three strategies: Markdown docs were split by header first, so a chunk never crosses a topic boundary, with a recursive splitter as a fallback for long sections. PDF runbooks (no header structure to exploit) got a straight recursive character split. HTML tickets were kept as one whole chunk per ticket whenever possible, because a resolution often only shows up in the final turn of the conversation, and splitting a ticket risks separating the question from its answer. 5 scanned PDFs with no extractable text layer were detected and skipped gracefully rather than OCR'd, a conscious call I'll come back to. Result: 95 of 100 document

🌐 Read this article in English here . 1. Da primeira parte aos protocolos da linguagem Na Parte 1 , construímos a base do modelo de dados do Python: objetos possuem identidade, tipo e valor; nomes guardam referências para esses objetos; mutabilidade determina quais mudanças podem acontecer sem substituir o objeto; e containers armazenam referências para outros objetos. Agora vamos avançar uma camada. O tipo de um objeto não determina apenas quais valores ele pode representar. Ele também determina quais operações aquele objeto suporta : se possui tamanho, se pode ser percorrido, comparado, indexado, chamado como função, usado em um with e assim por diante (PYTHON SOFTWARE FOUNDATION, 2026a). É aqui que entram os métodos especiais . Uma observação importante antes de continuar: na Parte 1 usamos o endereço de memória como modelo mental para identidade. De forma mais rigorosa, Python garante que a identidade de um objeto é estável durante sua existência. No CPython , especificamente, id(obj) corresponde ao endereço de memória do objeto; isso é um detalhe da implementação de referência, não uma garantia da linguagem (PYTHON SOFTWARE FOUNDATION, 2026a). A mesma distinção será importante quando falarmos sobre garbage collection e finalização: Python especifica o comportamento da linguagem; CPython é uma implementação desse comportamento . Versão de referência Os comportamentos e referências deste artigo foram revisados com base na documentação oficial do Python 3.14.7 . Detalhes exclusivos do CPython serão identificados explicitamente. 2. O que são métodos especiais Na documentação oficial, nomes como __len__ , __iter__ e __add__ são chamados de special methods , ou métodos especiais, na comunidade também é comum encontrar os termos métodos mágicos ou dunder methods ( dunder vem de double underscore por causa do padrão __nome__ ). Eles permitem que classes definidas por nós participem de operações que fazem parte da própria sintaxe e das funções embutidas da linguagem. Po

Implied vs Realized Volatility: Reading the Gap By Shakti Tiwari · Educational only · Not investment advice This article explains implied vs realized volatility: reading the gap from first principles. No live market numbers are quoted; the structure is what lasts. Why this matters Implied vs Realized Volatility: Reading the Gap is one of those subjects that sounds simple until you implement it, at which point the hidden complexity appears. The first version works on a laptop with a tiny file; the second version breaks at 3am when the WebSocket drops, the replay file is half-written, and you cannot tell which ticks you already stored. This article is a structural walkthrough: the concepts, the math where it helps, the code shape where it helps, and the failure modes that quietly cost money or correctness. No live market numbers are quoted because a number without a dated source is decoration, not education. The structure here does not expire, and unlike a specific price level, you can reuse it on the next dataset without re-deriving anything. If you only remember one sentence from this page, make it this: the boring parts are the product, and the interesting parts are a small fraction of what separates a demo from a system. Core concept At its heart, implied vs realized volatility: reading the gap is about being honest with your own assumptions. The trap is not that the idea is wrong; it is that a half-implemented version looks right in a demo and breaks in production. We separate the idea from the implementation so you can tell which one you actually have. A clean concept on paper can still produce a broken system if the boundary between 'what I meant' and 'what the code does' is never made explicit. Write the concept as a contract: given X observable at time t, the system produces Y, and any deviation is a bug, not a feature. A contract you can state in one sentence is also one you can test in one assertion, and that testability is the entire difference between an

GitHub热门项目 | An open-source, GPU-accelerated physics simulation engine built upon NVIDIA Warp, specifically targeting roboticists and simulation researchers. | Stars: 5,341 | 15 stars today | 语言: Python

GitHub热门项目 | Community-contributed instructions, agents, skills, and configurations to help you make the most of GitHub Copilot. | Stars: 37,813 | 47 stars today | 语言: Python

The problem Your VPN client shows a green "Connected" toggle. That's a marketing claim, not a proof. A tunnel can be up while DNS leaks, IPv6 bypasses the route, or your "anonymous" egress sits in a datacenter that any service can fingerprint. How ActiveVPN works The scan collects five groups of signals: Network interfaces — checks psutil.net_if_addrs() against patterns like tun, tap, utun, wg, ipsec, tailscale, zerotier. Processes — iterates running processes and matches them against known VPN/Tor binaries using exact/CLI-token matching (this removed a lot of naive-substring false positives, e.g. "vpn" matching random apps). External IP — queries ip-api.com, ipinfo.io, and ipapi.co in a failover chain for IP, ISP, country, hosting, and proxy flags. DNS — calls edns.ip-api.com to find the resolver IP your DNS queries actually go through. IPv4/IPv6 — fetches both via ipify to spot IPv6 leaks around an IPv4-only tunnel. Verdict scoring Each signal has a weight (interface 50, VPN process 40, Tor 35, hosting 25, proxy 30). The sum, capped at 100, maps to: 0-19 CLEAN 20-39 SUSPICIOUS 40-74 LIKELY VPN/PROXY 75-100 VPN DETECTED Extras worth mentioning Kill switch: sudo activevpn --kill / --kill-force. Watch mode: activevpn --watch 30 with on_change callbacks for VPN-drop alerts. History & export: JSON/CSV/TXT from the platform data directory. Exit codes (0/1/2) so you can wire it into CI. Library API: import activevpn; result = activevpn.scan(); result.verdict.label. Docker image + GitHub Pages docs + full pytest suite running on 3 OSes across Python 3.8 and 3.12. Install pip install activevpn activevpn GitHub: https://github.com/rkriad585/ActiveVPN Docs: https://rkriad585.github.io/ActiveVPN

Every generative-AI app I worked on hit the same wall. Pick a backend — OpenAI for images, Volcengine for video, Mureka for music — and before long the app is full of that provider's SDK quirks: its field names, its sync-vs-async polling loop, its error shapes. Then if want to swap one backend, or add a second one for failover, and it's a rewrite. mm-gateway is an open-source Python gateway that sits in front of that mess. One provider-neutral contract — over 13 backends : OpenAI · Google · xAI · DashScope · Volcengine · Flux · Stability · ElevenLabs · MiniMax · Mureka · ACE-Step · OpenRouter · UdioAPI The idea is simple: provider wire formats never appear in application code. Every request goes through a strict, modality-specific envelope — an ordered list of typed input parts plus provider-neutral parameters — and each backend adapter translates that to its native SDK or REST shape. For more information, visit https://github.com/sloth-os/mm-gateway

Nearly every AI agent benchmark you read is unfalsifiable. Not wrong, necessarily - unfalsifiable. There's a blog post with a bar chart, a claim that framework A beat framework B, and no way for you to check it. No run count. No model version. No raw output. Often no cost. You are asked to trust a summary statistic produced by people with an interest in the result. We publish agent benchmarks, so this is our problem too. This post is about the evidence bundle we settled on, and how you can pull one down and take it apart in about two minutes. Every command below is one I actually ran while writing this, with its real output pasted in. The claim we're going to try to break From one of our pilot runs: LangGraph 1.2.9 and Pydantic AI 2.13.0 both completed 20 of 20 tasks under gpt-4o , at a total spend of $0.094275. That's the sort of sentence you'd normally have to take on faith. Let's not. Two minutes to verify it yourself The bundle is a directory in a public repo. Pull it: BASE = "https://raw.githubusercontent.com/benchclawio/harness/main/results/gpt-4o-vs-gpt-4o-mini-tool-calling-2026-07-24" for f in SHA256SUMS README.md gpt4o-pilot-manifest-v0.4.0.json \ scored-pilot-gpt4o-raw-2026-07-24.jsonl \ scored-pilot-raw-2026-07-24.jsonl \ scored-pilot-analysis-2026-07-24.json \ scored-pilot-gpt4o-analysis-2026-07-24.json \ real-pilot-status-manifest-v0.3.0.json ; do curl -sfO " $BASE / $f " done First question: is this the same data we published, or has something drifted? sha256sum -c SHA256SUMS README.md: OK gpt4o-pilot-manifest-v0.4.0.json: OK real-pilot-status-manifest-v0.3.0.json: OK scored-pilot-analysis-2026-07-24.json: OK scored-pilot-gpt4o-analysis-2026-07-24.json: OK scored-pilot-gpt4o-raw-2026-07-24.jsonl: OK scored-pilot-raw-2026-07-24.jsonl: OK That's the cheapest integrity control there is and almost nobody ships it. It costs one line in your run script and it means a reader can tell the difference between the file you published and a file someone edited afte

Rate limiting sounds like a solved problem until you actually implement one and watch it fail in a way your load test didn't predict: legitimate bursts getting rejected, or a limiter that lets through 2x its stated limit at window boundaries. The failure modes are specific enough that it's worth working through the two dominant algorithms — token bucket and sliding window — with actual code, not just the diagrams. The problem with fixed windows The naive approach almost everyone reaches for first is a fixed window counter: pick a window size (say, 60 seconds), count requests in that window, reset the counter when the window rolls over. import time class FixedWindowLimiter : def __init__ ( self , limit : int , window_seconds : int ): self . limit = limit self . window_seconds = window_seconds self . count = 0 self . window_start = time . time () def allow ( self ) -> bool : now = time . time () if now - self . window_start >= self . window_seconds : self . window_start = now self . count = 0 if self . count < self . limit : self . count += 1 return True return False This is simple and cheap, and it's also broken in a specific, exploitable way. Say the limit is 100 requests/minute. A client can send 100 requests in the last second of window N, then another 100 in the first second of window N+1. That's 200 requests in roughly two seconds, well within the letter of "100/minute" as the code enforces it, but nowhere near the spirit of it. This is the classic boundary-burst problem, and it's the reason fixed windows get replaced once traffic is adversarial or bursty enough to find the seam. Sliding window: smoothing the boundary A sliding window log fixes this by tracking actual timestamps instead of a single counter, and counting how many fall within the trailing window at the moment of the request: from collections import deque import time class SlidingWindowLogLimiter : def __init__ ( self , limit : int , window_seconds : float ): self . limit = limit self . window_seco

Birinci bölümde bir haber sitesinin yayın akışını ajana devrettiğimi yazmıştım. O yazıdan sonra sistemin en kırılgan yerini kurdum: sosyal medyaya konuşan sanal sunucular . Dokuz kategorinin dokuz karakteri var, her biri kendi videosuyla kendi bölümünü tanıtıyor. Bu yazı o hattın kurulum günlüğü. İçinde çalışan kod da var, çöpe giden yedi deneme de. Neden karakter? Statik bir yazı linkini X'e atınca ölçüm net: kart önizlemesi görünür, kimse durmaz. Dikey videoda konuşan bir insan varsa akış duruyor. Elimde gerçek sunucu yok, o yüzden karakterleri üretiyoruz: Elif (bilim, psikoloji), Arda (oyun), Doruk (doğa ve kamp), Dr. Sinan (tıp), Defne (kitap), Süreyya (tarot), Meriç (dünya basını), Elvan (arkeoloji), Duru (güzellik). Kural basit ve sabit: kategori → karakter eşlemesi değişmez. Aynı etiket her zaman aynı yüz ve aynı sesle geliyor. Takipçi ikinci videoda karakteri tanıyor. Üretim hattı şöyle: konu seçimi → yazı yayını → başlangıç karesi (t2i) → konuşma metni (4 kısa cümle) → i2v video (12 sn, ses dahil) → Whisper doğrulama (eşik 0,80) → kafa1milyon.com etiketi (ffmpeg drawtext) → X + Instagram + YouTube kuyruğu Kritik yer dördüncü satır. Onu anlatayım. Telaffuz savaşı: modelin metni "düzeltmesi" Video modeline Türkçe bir cümle verip "bunu oku" dediğinizde, model okumakla kalmıyor. Metni kendi kendine yeniden yazıyor. Bir inek videosu altı kez çöpe gitti. Model "bilim insanları ile birlikte de bilim insanları" diye kelimeyi tekrarladı. Tıp videosunda "insülin" kelimesini "insülün" diye söyledi ve cümleyi kendi kendine "Tip 1 diyabette beta hücreleri..." diye temkinli bilim diline çevirdi. Bir başkasında "eureka" kelimesi "ürika" oldu. Yedi denemeden sonra kural dosyasına şunlar girdi: Konuşma metni en fazla 4 cümle , cümle başına 4-7 kelime. Yabancı kökenli ve teknik kelime yok. "İnsülin" yerine "şekeri ayarlayan hücreler". İddialı cümle yok. Model abartıyı düzeltmeye çalışıp metni bozuyor; cümleyi baştan dürüst kurmak gerekiyor. Prompt'a "do not reword or rephras

What Is a Message Queue? A message queue is a buffer that stores messages between producers and consumers. Producers send data to the queue, and consumers read from it. The queue decouples the two sides so they don't need to know about each other. This is a core pattern in distributed systems. Think of it like a restaurant ordering system. You (the producer) write your order on a ticket and put it on a spindle. The kitchen (the consumer) picks tickets off the spindle when they're ready. You don't shout at the chef, and the chef doesn't wait for you. The spindle is the queue. Why Use a Message Queue? Three big reasons: Decoupling : Producers and consumers evolve independently. You can change one without touching the other. Buffering : Producers can run faster than consumers. The queue absorbs spikes and prevents overload. Scaling : You can add more consumers to handle more load, or more producers to generate more work. Core Concepts Producer : Sends messages. Consumer : Receives messages. Queue : Stores messages until consumed. Broker : The server that hosts the queue (e.g., RabbitMQ, Kafka, Redis). Acknowledgment : When a consumer tells the broker it successfully processed a message. Dead Letter Queue : Where messages go if they can't be processed after retries. Simple Example with Redis Redis has a simple list-based queue using LPUSH and BRPOP . Here's a minimal Python example using redis-py . import redis import time r = redis . Redis ( host = ' localhost ' , port = 6379 ) # Producer r . lpush ( ' tasks ' , ' send_email ' ) r . lpush ( ' tasks ' , ' generate_report ' ) # Consumer (blocking pop) while True : task = r . brpop ( ' tasks ' , timeout = 5 ) if task : print ( f " Processing: { task [ 1 ]. decode () } " ) time . sleep ( 1 ) # simulate work else : break This is a simple FIFO queue. It works for basic cases but lacks features like acknowledgments, retries, and routing. Real-World Example with RabbitMQ RabbitMQ is a full-featured broker. Here's a producer an

Python's value comes not only from handling a great deal of data; its biggest asset comes from translating that data into meaningful business insight, and that business insight is used to make better business decisions. For businesses striving to increase customer satisfaction, enhance sales figures, and make smarter choices, a deep understanding of customer behavior is essential. Valuable business data includes customer transaction histories, website visits, product reviews, and responses to marketing efforts. When data such as this is analyzed, companies can effectively identify trends, understand preferences, and predict what their customers will do in the future. Python is the most popular when it comes to customer behavior analysis due to its comprehensive set of libraries, ranging from data cleaning, analysis, visualization, and machine learning; its flexibility makes it useful for new as well as seasoned data analysts. Why Analyze Customer Behavior? Customer behavior analysis assists businesses in answering key business questions such as: What are the products a customer buys most frequently? What spending figures do different customer groups have? Which customers are most likely to discontinue their service/products? What factors influence the customer's decision to purchase? Which marketing channels seem to receive the highest engagement? With answers like these, companies can implement targeted marketing campaigns, improve their product and services, customize experiences, and retain more customers. Key Python Libraries Some Python libraries that business data analysts use most frequently are: Pandas: Used for data cleaning, organizing, filtering, and manipulating datasets. NumPy: Provides a collection of high-level mathematical functions to perform numerical operations and work with arrays efficiently. Matplotlib: Enables users to create and plot static, animated, and interactive visualizations. Seaborn: An excellent library for plotting statistical graph

I’ve been building an open-source project called TraceMotive. It started from a problem I kept running into with AI agents: When an agent run fails, the place where the error appears isn’t always where the execution first started going wrong. That makes debugging agent workflows harder than it looks. So I built TraceMotive, a local-first tracing and debugging tool for AI agent execution. What TraceMotive does The current v0.1 includes: Python SDK canonical traces and spans a local Collector backed by SQLite a React UI for inspecting agent runs optional OpenAI Agents SDK integration TraceMotive is local-first, and content capture is disabled by default. I’m intentionally keeping the first version small. I’m not trying to add replay, automatic root-cause analysis, cloud sync, or support for every agent framework yet. Why? I’d rather get real feedback before adding a lot of features. Right now I want people who actually build AI agents to try it and tell me: where setup is confusing what breaks what information is missing from traces what feels awkward in the API The longer-term direction is: “The causal debugger for AI agents.” Eventually, I want TraceMotive to help identify where an agent execution first started going in the wrong direction, instead of only showing where the final error appeared. But first, I want to make the basic observation and debugging layer solid. Try it PyPI: pip install tracemotive GitHub: https://github.com/doraemonfv-glitch/tracemotive If you build AI agents, I’d really appreciate you trying it for a few minutes and telling me what you run into. Even small feedback is useful.

GitHub: https://github.com/kaifcodec/user-scanner.git If you've spent any time mapping digital footprints or doing threat intelligence, you know the drill: run Holehe for email registration checks, jump over to Sherlock or Maigret for usernames, and manually piece together the findings. While Holehe set the benchmark for password recovery endpoint checks, modern targets use complex handles, and web anti-bot defenses have gotten aggressive. Lately, I've integrated user-scanner into my workflow—a high-concurrency Python CLI engine that merges email enumeration, username profiling, and automated cross-pivoting into a single execution stream. Here is a breakdown of how it holds up against legacy OSINT tools and why it’s worth adding to your toolkit. Tool Matrix: user-scanner vs. Traditional Registration Checkers Feature / Metric Holehe Sherlock / Maigret user-scanner Input Flexibility Email Only Username Only Dual Engine (380+ Vectors) Vector Split ~120 Email Sites Web Form Scrapers 155+ Email & 225+ Username Modules Target Pivoting Manual Manual Automated Recursive Cross-Scanning Infostealer Intel None None Built-In Hudson Rock API ( --hudson ) Networking Core Basic Async Standard Requests httpx + curl_cffi (TLS Impersonation) Output Options Text / JSON Text / CSV PDF (with Avatar Scrapes), JSON, CSV Package Support Pip Pip Pip, Virtualenv, Nix ( nix run ) Standout Technical Features 1. Automated Cross-Scanning & Pivot Chains ( --cross-scan ) The biggest time-saver is the pivot pipeline. Standard tools tell you whether a target exists on a platform and stop there. user-scanner parses profile metadata returned during a run—looking for linked accounts, published bios, handles, and public emails—and automatically launches follow-up scans across secondary modules. -e → Username Pivoting: Mines handles and linked profiles returned from an email lookup. -u → Email Pivoting: Harvests public email addresses listed on social profile pages. Configurable Chain Depth: Dial in how

When mapping digital footprints, security analysts and open-source intelligence (OSINT) practitioners rely heavily on registration checkers. For years, single-purpose utilities like Holehe were the industry standard for checking email recovery endpoints. However, modern target profiling requires deeper correlation, higher concurrency, and cross-platform pivoting across both emails and usernames. Enter user-scanner —a high-throughput, 2-in-1 Python OSINT engine designed for deep email registration checking, username profiling, and cross-scan intelligence. Technical Comparison: user-scanner vs. Legacy OSINT Tools Feature / Capability Holehe Sherlock / Maigret user-scanner Primary Input Vectors Email Only Username Only 2-in-1 (380+ Combined Vectors) Target Integration ~120 Email Sites Scrapes Web Forms 155+ Email & 225+ Username Sites Pivoting / Cross-Scanning ❌ No ❌ No ✅ Auto-Pivots (Email ↔ Username ↔ Links) Breach Intelligence ❌ No ❌ No ✅ Hudson Rock Infostealer API ( --hudson ) Engine Core Basic Async Basic Requests httpx + curl_cffi (TLS Impersonation) Reporting Formats CLI / JSON CLI / CSV / HTML PDF (with Media/Avatars), JSON, CSV Deployment / Ecosystem Pip Pip Pip, Virtual Env, Nix ( nix run ) Core Capabilities of user-scanner 1. Cross-Scan & Pivot Intelligence Engine Unlike legacy checkers that stop after returning a boolean hit, user-scanner features an automated cross-scanning engine ( --cross-scan ). It mines exposed handles, profile links, and secondary email addresses from initial scan metadata and recursively pivots across secondary target vectors. -e → Username: Extracts handles or social links exposed on an email's registered profile. -u → Email: Extracts public email addresses published on target profile pages. Multi-Depth Chains: Supports configurable chain depth ( --cross-depth ) and link validation rules ( --cross-links verified ). 2. Infostealer Breach Intelligence ( --hudson ) Integrates directly with Hudson Rock's infostealer malware infection l

GitHub热门项目 | An Industrial-Level Controllable and Efficient Zero-Shot Text-To-Speech System | Stars: 22,800 | 137 stars today | 语言: Python