semvec/pypi-packages huggingface dataset:
drf-captcha 0.2.1
A - hopefully maintained - fork of django-simple-captcha to keep up with upgrading dependencies
License: MIT
Requires Python: <4.0,>=3.8

# Django rest captcha

Lightweight version of `django-simple-captcha` for work with `django-rest-framework`.


## Features

- Speed: use `cache` instead of database
- Safety: union methods for generate key and image. (You can't generate many images for one key)
- Easy: only one rest api (for generate, refresh image).


## Usage
Add `RestCaptchaSerializer` to your protected request validator:
```
from rest_captcha serializer import RestCaptchaSerializer
class HumanOnlyDataSerializer(RestCaptchaSerializer):
    pass
```
This code add to your serializer two required fields (captcha_key, captcha_value)


For provide this fields client(js code) should generate key:
```
> curl -X POST http:localhost:8000/api/captcha/ | python -m json.tool
{
    'image_type': 'image/png',
    'image_decode': 'base64',
    'captcha_key': 'de67e7f3-72d9-42d8-9677-ea381610363d',
    'captcha_value': '... image encoded in base64'
}
```
`captcha_value` - is base64 encoded PNG image, client should decode and show this image to human for validation and send letters from captcha to protected api.
If human have mistake - client should re generate your image.

**Note:** See also [trottling](https://www.django-rest-framework.org/api-guide/throttling/) for protect public api


## Install
```
> pip install django-rest-captcha
```

### Add to your settings.py
Add to installed apps:
```
INSTALLED_APPS = (
    ...
    'rest_captcha',
)
```

Set rest_captcha settings (if you want), see defaults:
```
REST_CAPTCHA = {
    'CAPTCHA_CACHE': 'default',
    'CAPTCHA_TIMEOUT': 300,  # 5 minutes
    'CAPTCHA_LENGTH': 4,
    'CAPTCHA_FONT_SIZE': 22,
    'CAPTCHA_IMAGE_SIZE': (90, 40),
    'CAPTCHA_LETTER_ROTATION': (-35, 35),
    'CAPTCHA_FOREGROUND_COLOR': '#001100',
    'CAPTCHA_BACKGROUND_COLOR': '#ffffff',
    'CAPTCHA_FONT_PATH': FONT_PATH,
    'CAPTCHA_CACHE_KEY': 'rest_captcha_{key}.{version}',
    'FILTER_FUNCTION': 'rest_captcha.captcha.filter_default',
    'NOISE_FUNCTION': 'rest_captcha.captcha.noise_default'
}
```

We recommend using redis or local memory as cache with set parameter, with bigger value of MAX_ENTRIES:
```
CACHES={
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'rest-captcha',
        'MAX_ENTRIES': 10000,
    }
}
```

### Add hooks to your app router (urls.py):
```
urlpatterns = [
    ...
    url(r'api/captcha/', include('rest_captcha.urls')),
]
```
semantic-complexity 0.0.25
Multi-dimensional code complexity analyzer
License: MIT
Requires Python: >=3.10
Keywords: code-analysis, cognitive, complexity, cyclomatic, metrics

# semantic-complexity (Python)

Multi-dimensional code complexity analyzer for Python.

## Installation

```bash
pip install semantic-complexity
```

### uv를 통한 설치

```bash
# 글로벌 도구로 설치
uv tool install semantic-complexity

# 또는 일회성 실행
uvx semantic-complexity path/to/file.py
```

## MCP 서버 설치

Claude Code에서 MCP 서버로 사용하려면:

```bash
# MCP 서버 추가 (Python 버전)
claude mcp add sc-py "uvx --from semantic-complexity semantic-complexity-py-mcp"
```

### 기존 MCP 업데이트/재설치

```bash
# 1. 기존 MCP 삭제
claude mcp remove sc-py

# 2. 캐시 정리 (최신 버전 반영)
uv cache clean semantic-complexity --force

# 3. 재설치
claude mcp add sc-py "uvx --from semantic-complexity semantic-complexity-py-mcp"

# 설치 확인
claude mcp list
```

## Usage

### CLI

```bash
# Analyze a file
semantic-complexity path/to/file.py

# Analyze a directory
semantic-complexity path/to/project/

# Output as Markdown report
semantic-complexity path/to/project/ -f markdown -o report.md

# Filter by threshold
semantic-complexity path/to/project/ --threshold 20
```

### Python API

```python
from semantic_complexity import analyze_source, analyze_functions

# Analyze source code
result = analyze_source("""
def complex_function(x):
    if x > 0:
        for i in range(x):
            if i % 2 == 0:
                print(i)
""")

print(f"Weighted complexity: {result.weighted}")
print(f"Control: {result.control}")
print(f"Nesting: {result.nesting}")
print(f"Contributions: {result.contributions}")

# Analyze functions individually
functions = analyze_functions(source)
for fn in functions:
    print(f"{fn.name}: McCabe={fn.cyclomatic}, Dimensional={fn.dimensional.weighted}")
```

## Domains

| Domain | Weight | Description |
|--------|--------|-------------|
| Control (C) | 1.0 | Cyclomatic complexity (branches, loops) |
| Nesting (N) | 1.5 | Depth penalty |
| State (S) | 2.0 | State mutations and transitions |
| Async (A) | 2.5 | Async/await, coroutines |
| Coupling (Λ) | 3.0 | Hidden dependencies, side effects |

## License

MIT