What Programming Languages Are Used in user-scanner? A Complete Codebase Analysis

The user-scanner repository is implemented entirely in Python, with all executable code—including the core scanning engine, CLI entry point, and test suites—written as standard Python modules.

The kaifcodec/user-scanner project relies exclusively on the Python ecosystem for its runtime functionality. While the repository includes configuration files like pyproject.toml and requirements.txt, these are data-definition formats rather than programming languages. Every functional component, from argument parsing to result aggregation, lives within the Python codebase.

Primary Programming Language: Python

According to the source code in kaifcodec/user-scanner, the project maintains a 100% Python implementation. The architecture centers on several key modules that handle scanning orchestration and result processing.

Core Python Modules

The project's functionality is distributed across these primary Python files:

• user_scanner/core/engine.py – Contains the Engine class that orchestrates email and username availability checks
• user_scanner/core/orchestrator.py – Handles high-level scan orchestration and result aggregation logic
• user_scanner/__main__.py – Serves as the CLI entry point, parsing command-line arguments and initializing scans
• user_scanner/core/result.py – Defines the Result class used to report scan outcomes and metadata
• tests/*.py – Comprehensive pytest suite validating the Python implementation

No compiled extensions, JavaScript frontends, or other programming languages appear in the executable codebase. Even the CLI interface is implemented as a standard Python module invocation.

Working with the Python API

The library exposes functionality through standard Python imports. You can interact with user-scanner both as a command-line tool and as a programmatic library.

CLI Entry Point

Execute scans directly from the command line using Python's module execution syntax:

# Execute the CLI entry point

# (equivalent to running `python -m user_scanner --email example@example.com`)

import user_scanner.__main__  # noqa: F401

This imports the __main__.py module, which parses arguments and launches the scanning workflow defined in the orchestrator.

Programmatic Engine Usage

For integration into existing Python applications, instantiate the Engine class directly:

from user_scanner.core.engine import Engine

# Initialise the engine with default configuration

engine = Engine()

# Perform an email scan

result = engine.scan_email("example@example.com")
print(result)          # → Result object indicating availability / metadata

The Engine class in user_scanner/core/engine.py serves as the primary interface for all scanning operations.

Result Object Inspection

Scan results are encapsulated in dedicated Python objects defined in user_scanner/core/result.py:

from user_scanner.core.result import Result

# Example of constructing a Result manually

res = Result.taken(extra={"username": "example"}, media=["https://img.example.com/avatar.png"])
print(res.is_taken)    # True

print(res.extra)       # {'username': 'example'}

The Result class provides properties like is_taken and extra metadata, demonstrating pure Python object-oriented design patterns.

Supporting File Types

While the programming language is exclusively Python, the repository includes several non-code files that support the build and documentation process:

• pyproject.toml – Python packaging configuration (TOML format)
• requirements.txt – Dependency specification (text format)
• README.md – Documentation (Markdown format)
• JSON configuration files – Data storage for scan targets or settings

These files contain no executable logic and do not constitute additional programming languages used by the project.

Summary

• The user-scanner project uses Python as its sole programming language for all executable code
• Core functionality resides in modules like user_scanner/core/engine.py and user_scanner/core/orchestrator.py
• The CLI entry point at user_scanner/__main__.py and all tests in tests/*.py are pure Python
• Configuration files use data formats (TOML, JSON, Markdown) but do not contain programming logic
• The library can be consumed via standard Python imports without external language dependencies

Frequently Asked Questions

Is user-scanner written in multiple programming languages?

No. According to the kaifcodec/user-scanner source code, the project is implemented entirely in Python. While supporting files use formats like TOML for pyproject.toml and Markdown for documentation, all executable code—including the scanning engine, CLI interface, and test suites—consists of standard Python modules.

Can I use user-scanner as a Python library?

Yes. The project is designed for both CLI and programmatic use. Import the Engine class from user_scanner.core.engine to perform scans directly within your Python applications, or work with Result objects from user_scanner.core.result to handle scan outcomes programmatically.

Does user-scanner rely on any compiled extensions or C modules?

Based on the source code analysis, user-scanner contains no compiled extensions or C modules. The implementation in user_scanner/core/engine.py and related modules uses pure Python, relying on standard library imports and the pytest framework for testing.

Where are the test files located in user-scanner?

All tests reside in the tests/ directory as Python files (.py). The test suite uses pytest to validate the pure Python implementation, covering functionality from the core engine to the orchestrator logic without requiring external language runtimes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}