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

> Discover the programming languages powering the user-scanner project. This codebase analysis reveals Python as the sole language, used for its scanning engine, CLI, and tests.

- Repository: [Kaif/user-scanner](https://github.com/kaifcodec/user-scanner)
- Tags: internals
- Published: 2026-08-30

---

**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`](https://github.com/kaifcodec/user-scanner/blob/main/pyproject.toml) and [`requirements.txt`](https://github.com/kaifcodec/user-scanner/blob/main/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`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/core/engine.py)** – Contains the `Engine` class that orchestrates email and username availability checks
- **[`user_scanner/core/orchestrator.py`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/core/orchestrator.py)** – Handles high-level scan orchestration and result aggregation logic
- **[`user_scanner/__main__.py`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/__main__.py)** – Serves as the CLI entry point, parsing command-line arguments and initializing scans
- **[`user_scanner/core/result.py`](https://github.com/kaifcodec/user-scanner/blob/main/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:

```python

# 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`](https://github.com/kaifcodec/user-scanner/blob/main/__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:

```python
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`](https://github.com/kaifcodec/user-scanner/blob/main/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`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/core/result.py):

```python
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`](https://github.com/kaifcodec/user-scanner/blob/main/pyproject.toml)** – Python packaging configuration (TOML format)
- **[`requirements.txt`](https://github.com/kaifcodec/user-scanner/blob/main/requirements.txt)** – Dependency specification (text format)
- **[`README.md`](https://github.com/kaifcodec/user-scanner/blob/main/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`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/core/engine.py) and [`user_scanner/core/orchestrator.py`](https://github.com/kaifcodec/user-scanner/blob/main/user_scanner/core/orchestrator.py)
- The CLI entry point at [`user_scanner/__main__.py`](https://github.com/kaifcodec/user-scanner/blob/main/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`](https://github.com/kaifcodec/user-scanner/blob/main/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`](https://github.com/kaifcodec/user-scanner/blob/main/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.