semvec/pypi-packages huggingface dataset:
application-analysis 1.0.2
Comprehensive Python code analyzer with HTML reporting
Requires Python: >=3.10
Keywords: code-analysis, static-analysis, python, linter, code-quality

# Application Analysis Tool

A comprehensive Python code analyzer that generates static HTML reports.

## Installation

```bash
pip install application-analysis
```

## Usage

After installation, run from command line:

```bash
analyze-app <path-to-project>
```

### Options

```
analyze-app <path> [options]

Arguments:
  path                    Path to the Python project to analyze

Options:
  -o, --output PATH       Output HTML report path (default: report.html)
  --skip-dynamic          Skip runtime analysis
  --skip-llm              Skip LLM-powered analysis (requires OPENAI_API_KEY)
  -q, --quiet             Suppress progress output
  --no-browser            Don't auto-open report in browser
```

### Examples

```bash
# Basic analysis
analyze-app ./my_project

# Custom output path
analyze-app ./my_project -o analysis_report.html

# Quick analysis without LLM
analyze-app ./my_project --skip-llm

# Silent mode, no browser
analyze-app ./my_project -q --no-browser
```

## Environment Variables

- `OPENAI_API_KEY` - Required for LLM-powered analysis features (optional)

## What It Analyzes

- **Placeholders/Stubs** - TODOs, FIXMEs, stub functions, mock patterns
- **Complexity** - Cyclomatic complexity, nesting depth, lines of code
- **Execution Flow** - Call graphs, entrypoints, architecture violations
- **Naming** - Magic identifiers, naming conventions
- **Dead Code** - Unused imports, functions, unreachable code
- **Security** - Hardcoded secrets, eval/exec, SQL injection patterns
- **Duplication** - Duplicate functions and code blocks
- **Logging** - Log quality, spam detection
- **Metrics** - Training metric stagnation (for ML projects)

## Output

Generates a self-contained HTML report with:
- Health score (0-100) and letter grade (A-F)
- Executive summary
- Detailed findings by category
- Actionable recommendations
threaded-map-reduce 0.1.0
A threaded version of map reduce
Requires Python: >=3.13

# threaded-map-reduce

A Python library that implements **map**, **unordered map**, and **map-reduce** using threads.

This library is intented to be performant for CPU-bound tasks.
The map implementation has been tested to be much more performant than the map method of the [futures.ThreadPoolExecutor](https://docs.python.org/3/library/concurrent.futures.html#concurrent.futures.ThreadPoolExecutor) class of the standar library.

---

## Features

* **Parallel map** with deterministic order: `map`
* **Parallel unordered map** for maximum throughput: `map_unordered`
* **Parallel map-reduce**: `map_reduce`
* It groups items into chunks to reduce the parallelization overhead
* No external dependencies

---

## Installation

```bash
pip install threaded-map-reduce
```

(Or, if you use `uv`:)

```bash
uv pip install threaded-map-reduce
```

---

## Quick Start

### 1. Parallel map (ordered)

```python
from threaded_map_reduce import map

def square(x):
    return x * x

nums = range(1000)
result = list(threaded_map(square, nums, num_computing_threads=4, chunk_size=100))
print(result[-10:])
```

---

### 2. Parallel map (unordered)

Faster, but order is not preserved:

```python
from threaded_map_reduce import map_unordered

nums = range(1000)
result = list(map_unordered(square, nums, num_computing_threads=4, chunk_size=100))
print(sorted(result))
print(result[-10:])
```

---

### 3. Parallel map-reduce

Useful for reductions such as sums, counts, or any associative operation.

```python
from operator import add
from threaded_map_reduce import map_reduce

def square(x):
    return x * x

nums = range(0, 1000)
result = map_reduce(square, add, nums,
                    num_computing_threads=4,
                    chunk_size=100)
print(result)
```

---

## API Summary

### `threaded_map(map_fn, items, num_computing_threads, chunk_size)`

Runs `map_fn` over every item in parallel and yields results keeping input order.

### `map_unordered(map_fn, items, num_computing_threads, chunk_size)`

Same as above, but yields items in any order.

### `map_reduce(map_fn, reduce_fn, items, num_computing_threads, chunk_size)`

Maps items in parallel, reduces mapped chunks using the provided reducer function, and returns a single result.

---

## License

MIT License.