# DevKitX
**Comprehensive quality-of-life utilities for Python developers**
A modern, type-safe toolkit providing essential utilities for common development tasks including JSON manipulation, file operations, logging, CLI utilities, HTTP clients, data processing, string manipulation, configuration management, system operations, async utilities, development tools, security functions, time utilities, and validation.
[](https://www.python.org/downloads/)
[](LICENSE)
[](https://mypy-lang.org/)
## Features
- 🚀 **Modern Python**: Built for Python 3.10+ with full type annotations
- 📦 **Comprehensive**: 14+ utility modules covering common development needs
- ⚡ **Async Support**: Async-compatible utilities and bridges between sync/async code
- 🔒 **Security**: Built-in security utilities for hashing, JWT tokens, and input sanitization
- 🛠️ **Developer Tools**: Profiling, debugging, and testing utilities
- 🌐 **HTTP Client**: Robust HTTP utilities with retry logic and async support
- 📝 **Configuration**: Multi-format config management (JSON, YAML, TOML, .env)
- 🎨 **CLI Tools**: Rich terminal output with colors, progress bars, and interactive prompts
- 🔧 **System Utils**: Cross-platform system information and process management
- ✅ **Validation**: Comprehensive input validation and schema checking
## Installation
```bash
pip install devkitx
```
## Quick Start
```python
from devtools_py import json_utils, string_utils, http_utils, config_utils
# JSON operations with enhanced features
data = json_utils.load_json("config.json")
flat_data = json_utils.flatten_json(data)
pretty_output = json_utils.pretty_json(data, color=True)
# String manipulation and validation
snake_case = string_utils.to_snake_case("CamelCaseString")
is_valid_email = string_utils.validate_email("user@example.com")
clean_filename = string_utils.sanitize_filename("file<name>.txt")
# HTTP requests with automatic retries
response = http_utils.api_request("GET", "https://api.example.com/data")
client = http_utils.BaseAPIClient("https://api.example.com")
users = client.get("/users")
# Configuration management
config = config_utils.ConfigManager(["config.json", "config.yaml"])
config.load()
database_url = config.get("database.url", "sqlite:///default.db")
```
## Module Overview
### Core Utilities
#### JSON Utils (`json_utils`)
Enhanced JSON operations with pretty printing and flattening:
```python
from devtools_py import json_utils
# Load and save JSON with automatic formatting
data = json_utils.load_json("config.json")
json_utils.save_json(data, "backup.json", pretty=True)
# Flatten nested JSON for easier processing
nested = {"user": {"profile": {"name": "John", "age": 30}}}
flat = json_utils.flatten_json(nested)
# Result: {"user.profile.name": "John", "user.profile.age": 30}
# Pretty print with optional syntax highlighting
print(json_utils.pretty_json(data, color=True))
```
#### File Utils (`file_utils`)
Cross-platform file operations with safety features:
```python
from devtools_py import file_utils
# Find files with glob patterns or exact names
python_files = file_utils.find_file("*.py", "src")
config_file = file_utils.find_file("config.json", ".")
# Safe file operations
file_utils.ensure_dir("output/data")
file_utils.atomic_write("important.json", '{"key": "value"}')
file_utils.copy_file("source.txt", "backup.txt", overwrite=False)
# Check permissions
if file_utils.is_writable("output.txt"):
# Safe to write
pass
```
#### String Utils (`string_utils`)
Comprehensive string manipulation and validation:
```python
from devtools_py import string_utils
# Case conversions
string_utils.to_snake_case("CamelCase") # "camel_case"
string_utils.to_camel_case("snake_case") # "snakeCase"
string_utils.to_pascal_case("kebab-case") # "KebabCase"
string_utils.to_kebab_case("PascalCase") # "pascal-case"
# Validation
string_utils.validate_email("user@example.com") # True
string_utils.validate_url("https://example.com") # True
# Text processing
string_utils.sanitize_filename("file<name>.txt") # "file_name_.txt"
string_utils.truncate_text("Long text here", 10) # "Long te..."
urls = string_utils.extract_urls("Visit https://example.com for info")
```
### Advanced Utilities
#### HTTP Utils (`http_utils`)
Robust HTTP client with retry logic and async support:
```python
from devtools_py import http_utils
import asyncio
# Synchronous requests with automatic retries
response = http_utils.api_request(
"POST",
"https://api.example.com/users",
json_body={"name": "John", "email": "john@example.com"},
headers={"Authorization": "Bearer token"},
retries=3
)
# API client for consistent base URL and headers
client = http_utils.BaseAPIClient(
"https://api.example.com",
headers={"Authorization": "Bearer token"}
)
users = client.get("/users")
new_user = client.post("/users", json_body={"name": "Jane"})
# Async support
async def fetch_data():
async_client = http_utils.AsyncAPIClient("https://api.example.com")
return await async_client.get("/data")
# Batch requests with concurrency control
requests = [
("GET", "https://api.example.com/users/1", {}),
("GET", "https://api.example.com/users/2", {}),
]
responses = await http_utils.async_batch_requests(requests, concurrency_limit=5)
```
#### Config Utils (`config_utils`)
Multi-format configuration management:
```python
from devtools_py import config_utils
# Load from multiple sources with precedence
config = config_utils.ConfigManager([
"config.json",
"config.yaml",
"local.env"
])
config.load()
# Type-safe configuration access
database_url = config.get("database.url", "sqlite:///default.db", str)
debug_mode = config.get("debug", False, bool)
max_connections = config.get("database.max_connections", 10, int)
# Environment variable integration
config.merge_env_vars("MYAPP_") # Loads MYAPP_* env vars
# Save configuration
config.set("new.setting", "value")
config.save("updated_config.json")
```
#### Security Utils (`security_utils`)
Security and cryptographic utilities:
```python
from devtools_py import security_utils
# Password hashing with bcrypt
hashed = security_utils.hash_password("my_secure_password")
is_valid = security_utils.verify_password("my_secure_password", hashed)
# Secure key generation
secret_key = security_utils.generate_secret_key(32)
uuid = security_utils.generate_uuid()
# Data hashing
file_hash = security_utils.hash_data(b"file content", "sha256")
# JWT tokens
payload = {"user_id": 123, "role": "admin"}
token = security_utils.generate_jwt_token(payload, secret_key, expires_in=3600)
decoded = security_utils.verify_jwt_token(token, secret_key)
# Input sanitization
clean_input = security_utils.sanitize_input("<script>alert('xss')</script>")
```
#### Async Utils (`async_utils`)
Bridge between sync and async code:
```python
from devtools_py import async_utils
import asyncio
# Convert sync functions to async
def slow_sync_function(x):
time.sleep(1)
return x * 2
async_func = async_utils.sync_to_async(slow_sync_function)
result = await async_func(5) # Non-blocking
# Convert async functions to sync
async def async_function(x):
await asyncio.sleep(0.1)
return x * 2
sync_func = async_utils.async_to_sync(async_function)
result = sync_func(5) # Blocks until complete
# Concurrency control
tasks = [fetch_data(url) for url in urls]
results = await async_utils.gather_with_limit(5, *tasks) # Max 5 concurrent
# Retry with exponential backoff
result = await async_utils.retry_async(
unreliable_api_call,
retries=3,
delay=1.0,
exceptions=(ConnectionError,)
)
# Async file operations
async_fm = async_utils.AsyncFileManager()
content = await async_fm.read_text("large_file.txt")
await async_fm.write_text("output.txt", "Hello, World!")
```
#### Development Utils (`dev_utils`)
Debugging and development tools:
```python
from devtools_py import dev_utils
# Function timing and profiling
@dev_utils.time_function
@dev_utils.profile_memory
def expensive_operation():
return [i**2 for i in range(10000)]
# Pretty printing complex objects
complex_data = {"users": [{"id": 1, "nested": {"deep": "value"}}]}
print(dev_utils.pretty_print_object(complex_data, max_depth=3))
# Test data generation
schema = {"name": str, "age": int, "active": bool}
test_data = dev_utils.generate_test_data(schema, count=10)
# Function benchmarking
def method1(): return sum(range(1000))
def method2(): return sum([i for i in range(1000)])
results = dev_utils.benchmark_functions(method1, method2, iterations=1000)
print(f"method1: {results['method1']:.4f}s avg")
# Mock HTTP server for testing
responses = {
"/api/users": {"users": [{"id": 1, "name": "John"}]},
"/api/status": {"status": "ok"}
}
server = dev_utils.MockHTTPServer(responses)
url = server.start()
# Make requests to url + "/api/users"
server.stop()
```
### System and Validation
#### System Utils (`system_utils`)
Cross-platform system operations:
```python
from devtools_py import system_utils
# System information
sys_info = system_utils.get_system_info()
python_info = system_utils.get_python_info()
# Command execution with timeout
result = system_utils.run_command(
["python", "--version"],
timeout=5.0,
cwd="/path/to/directory"
)
# Async command execution
result = await system_utils.run_command_async(["ls", "-la"])
# Utility functions
executable_path = system_utils.find_executable("python")
env_vars = system_utils.get_env_vars("PYTHON_")
is_root = system_utils.is_admin()
free_port = system_utils.get_free_port(8000)
```
#### Validation Utils (`validation_utils`)
Comprehensive input validation:
```python
from devtools_py import validation_utils
# Schema validation
schema = {"name": str, "age": int, "active": bool}
data = {"name": "John", "age": 30, "active": True}
errors = validation_utils.validate_schema(data, schema)
# Range and length validation
validation_utils.validate_range(25, 18, 65) # True
validation_utils.validate_length("hello", 3, 10) # True
validation_utils.validate_regex("test123", r"^\w+\d+$") # True
# JSON schema validation
json_schema = {
"type": "object",
"properties": {
"name": {"type": "string", "minLength": 1},
"age": {"type": "integer", "minimum": 0}
},
"required": ["name"]
}
errors = validation_utils.validate_json_schema(data, json_schema)
# Rule-based validator
validator = validation_utils.Validator()
validator.add_rule("email", lambda x: "@" in str(x), "Invalid email")
validator.add_rule("age", lambda x: isinstance(x, int) and x >= 0, "Invalid age")
errors = validator.validate({"email": "test@example.com", "age": 25})
```
#### Time Utils (`time_utils`)
Date and time utilities:
```python
from devtools_py import time_utils
from datetime import datetime
# Flexible date parsing
date = time_utils.parse_date("2024-01-15")
date = time_utils.parse_date("15/01/2024", ["%d/%m/%Y"])
# Duration formatting
duration = time_utils.format_duration(3661) # "1h 1m 1.0s"
# Business day calculations
is_weekday = time_utils.is_business_day(datetime(2024, 1, 15))
next_workday = time_utils.next_business_day(datetime(2024, 1, 12))
# Cron scheduling
next_run = time_utils.cron_next_run("0 9 * * 1-5") # 9 AM weekdays
# Timer utility
timer = time_utils.Timer()
timer.start()
# ... do work ...
elapsed = timer.stop()
# Or as context manager
with time_utils.Timer() as timer:
# ... do work ...
pass
print(f"Elapsed: {timer.elapsed():.2f}s")
```
### CLI and Logging
#### CLI Utils (`cli_utils`)
Rich terminal interfaces:
```python
from devtools_py import cli_utils
# Interactive prompts
password = cli_utils.password_prompt("Enter password:", confirm=True)
selected = cli_utils.multi_select(["option1", "option2", "option3"])
# Progress indicators
for item in cli_utils.progress_bar(range(100), "Processing"):
# Do work with item
pass
with cli_utils.spinner("Loading data..."):
# Long running operation
time.sleep(2)
# Colored output and tables
print(cli_utils.colored_text("Success!", "green", bold=True))
print(cli_utils.colored_text("Warning", "yellow"))
data = [{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]
table = cli_utils.table_format(data, headers=["Name", "Age"])
print(table)
```
#### Log Utils (`log_utils`)
Enhanced logging setup:
```python
from devtools_py import log_utils
import logging
# Quick logger setup
logger = log_utils.setup_logging("INFO", to_file="app.log")
logger = log_utils.setup_logging("DEBUG", json=True, use_loguru=True)
# Time logging context manager
with log_utils.log_time("database_query"):
# Database operation
pass
# Logs: "database_query took 123.45 ms"
# Function call logging
@log_utils.log_calls
def process_data(data):
return {"processed": len(data)}
result = process_data([1, 2, 3])
# Logs function calls and returns at DEBUG level
```
## CLI Interface
The toolkit also provides a command-line interface for common operations:
```bash
# String manipulation
devkitx string convert --to snake "CamelCase"
devkitx string validate --email "user@example.com"
# Configuration management
devkitx config merge config1.json config2.yaml
# Security utilities
devkitx security hash --algorithm sha256 "my-data"
devkitx security generate --type uuid
# System information
devkitx system info
devkitx system find-executable python
# Time utilities
devkitx time parse "2024-01-15 14:30:00"
devkitx time format-duration 3661
```
## Requirements
- Python 3.10 or higher
- Dependencies: `httpx`, `click`, `rich`, `bcrypt`, `PyJWT`
## Development
```bash
# Clone the repository
git clone https://github.com/ladycami/devkitx.git
cd devkitx
# Install in development mode
pip install -e ".[dev]"
# Run tests
pytest
# Run linting
ruff check src/
black --check src/
mypy src/
```
## Contributing
Contributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## Changelog
### v1.0.0 (Upcoming)
- Initial release with comprehensive utility modules
- Full type annotations and Python 3.10+ support
- Async utilities and HTTP client with retry logic
- Security utilities with JWT and bcrypt support
- Rich CLI interface with progress bars and colored output
- Multi-format configuration management
- Development and debugging tools
- Comprehensive test suite with 90%+ coverage
Raw data
{
"_id": null,
"home_page": null,
"name": "devkitx",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "async, bcrypt, cli, colored-output, configuration, cross-platform, debugging, developer-tools, devtools, env-files, files, http, json, jwt, logging, profiling, progress-bars, retry-logic, security, string-manipulation, system-utils, time-utils, toml, type-safe, utilities, validation, yaml",
"author": null,
"author_email": "LadyCami <ladycami@serityops.com>",
"download_url": "https://files.pythonhosted.org/packages/19/ca/29ca4085b1401fb24b7ee05d96b3c743df97430bbbd7d73bd1b9a2f030c8/devkitx-1.0.0.tar.gz",
"platform": null,
"description": "# DevKitX\n\n**Comprehensive quality-of-life utilities for Python developers**\n\nA modern, type-safe toolkit providing essential utilities for common development tasks including JSON manipulation, file operations, logging, CLI utilities, HTTP clients, data processing, string manipulation, configuration management, system operations, async utilities, development tools, security functions, time utilities, and validation.\n\n[](https://www.python.org/downloads/)\n[](LICENSE)\n[](https://mypy-lang.org/)\n\n## Features\n\n- \ud83d\ude80 **Modern Python**: Built for Python 3.10+ with full type annotations\n- \ud83d\udce6 **Comprehensive**: 14+ utility modules covering common development needs\n- \u26a1 **Async Support**: Async-compatible utilities and bridges between sync/async code\n- \ud83d\udd12 **Security**: Built-in security utilities for hashing, JWT tokens, and input sanitization\n- \ud83d\udee0\ufe0f **Developer Tools**: Profiling, debugging, and testing utilities\n- \ud83c\udf10 **HTTP Client**: Robust HTTP utilities with retry logic and async support\n- \ud83d\udcdd **Configuration**: Multi-format config management (JSON, YAML, TOML, .env)\n- \ud83c\udfa8 **CLI Tools**: Rich terminal output with colors, progress bars, and interactive prompts\n- \ud83d\udd27 **System Utils**: Cross-platform system information and process management\n- \u2705 **Validation**: Comprehensive input validation and schema checking\n\n## Installation\n\n```bash\npip install devkitx\n```\n\n## Quick Start\n\n```python\nfrom devtools_py import json_utils, string_utils, http_utils, config_utils\n\n# JSON operations with enhanced features\ndata = json_utils.load_json(\"config.json\")\nflat_data = json_utils.flatten_json(data)\npretty_output = json_utils.pretty_json(data, color=True)\n\n# String manipulation and validation\nsnake_case = string_utils.to_snake_case(\"CamelCaseString\")\nis_valid_email = string_utils.validate_email(\"user@example.com\")\nclean_filename = string_utils.sanitize_filename(\"file<name>.txt\")\n\n# HTTP requests with automatic retries\nresponse = http_utils.api_request(\"GET\", \"https://api.example.com/data\")\nclient = http_utils.BaseAPIClient(\"https://api.example.com\")\nusers = client.get(\"/users\")\n\n# Configuration management\nconfig = config_utils.ConfigManager([\"config.json\", \"config.yaml\"])\nconfig.load()\ndatabase_url = config.get(\"database.url\", \"sqlite:///default.db\")\n```\n\n## Module Overview\n\n### Core Utilities\n\n#### JSON Utils (`json_utils`)\nEnhanced JSON operations with pretty printing and flattening:\n\n```python\nfrom devtools_py import json_utils\n\n# Load and save JSON with automatic formatting\ndata = json_utils.load_json(\"config.json\")\njson_utils.save_json(data, \"backup.json\", pretty=True)\n\n# Flatten nested JSON for easier processing\nnested = {\"user\": {\"profile\": {\"name\": \"John\", \"age\": 30}}}\nflat = json_utils.flatten_json(nested)\n# Result: {\"user.profile.name\": \"John\", \"user.profile.age\": 30}\n\n# Pretty print with optional syntax highlighting\nprint(json_utils.pretty_json(data, color=True))\n```\n\n#### File Utils (`file_utils`)\nCross-platform file operations with safety features:\n\n```python\nfrom devtools_py import file_utils\n\n# Find files with glob patterns or exact names\npython_files = file_utils.find_file(\"*.py\", \"src\")\nconfig_file = file_utils.find_file(\"config.json\", \".\")\n\n# Safe file operations\nfile_utils.ensure_dir(\"output/data\")\nfile_utils.atomic_write(\"important.json\", '{\"key\": \"value\"}')\nfile_utils.copy_file(\"source.txt\", \"backup.txt\", overwrite=False)\n\n# Check permissions\nif file_utils.is_writable(\"output.txt\"):\n # Safe to write\n pass\n```\n\n#### String Utils (`string_utils`)\nComprehensive string manipulation and validation:\n\n```python\nfrom devtools_py import string_utils\n\n# Case conversions\nstring_utils.to_snake_case(\"CamelCase\") # \"camel_case\"\nstring_utils.to_camel_case(\"snake_case\") # \"snakeCase\"\nstring_utils.to_pascal_case(\"kebab-case\") # \"KebabCase\"\nstring_utils.to_kebab_case(\"PascalCase\") # \"pascal-case\"\n\n# Validation\nstring_utils.validate_email(\"user@example.com\") # True\nstring_utils.validate_url(\"https://example.com\") # True\n\n# Text processing\nstring_utils.sanitize_filename(\"file<name>.txt\") # \"file_name_.txt\"\nstring_utils.truncate_text(\"Long text here\", 10) # \"Long te...\"\nurls = string_utils.extract_urls(\"Visit https://example.com for info\")\n```\n\n### Advanced Utilities\n\n#### HTTP Utils (`http_utils`)\nRobust HTTP client with retry logic and async support:\n\n```python\nfrom devtools_py import http_utils\nimport asyncio\n\n# Synchronous requests with automatic retries\nresponse = http_utils.api_request(\n \"POST\", \n \"https://api.example.com/users\",\n json_body={\"name\": \"John\", \"email\": \"john@example.com\"},\n headers={\"Authorization\": \"Bearer token\"},\n retries=3\n)\n\n# API client for consistent base URL and headers\nclient = http_utils.BaseAPIClient(\n \"https://api.example.com\",\n headers={\"Authorization\": \"Bearer token\"}\n)\nusers = client.get(\"/users\")\nnew_user = client.post(\"/users\", json_body={\"name\": \"Jane\"})\n\n# Async support\nasync def fetch_data():\n async_client = http_utils.AsyncAPIClient(\"https://api.example.com\")\n return await async_client.get(\"/data\")\n\n# Batch requests with concurrency control\nrequests = [\n (\"GET\", \"https://api.example.com/users/1\", {}),\n (\"GET\", \"https://api.example.com/users/2\", {}),\n]\nresponses = await http_utils.async_batch_requests(requests, concurrency_limit=5)\n```\n\n#### Config Utils (`config_utils`)\nMulti-format configuration management:\n\n```python\nfrom devtools_py import config_utils\n\n# Load from multiple sources with precedence\nconfig = config_utils.ConfigManager([\n \"config.json\",\n \"config.yaml\", \n \"local.env\"\n])\nconfig.load()\n\n# Type-safe configuration access\ndatabase_url = config.get(\"database.url\", \"sqlite:///default.db\", str)\ndebug_mode = config.get(\"debug\", False, bool)\nmax_connections = config.get(\"database.max_connections\", 10, int)\n\n# Environment variable integration\nconfig.merge_env_vars(\"MYAPP_\") # Loads MYAPP_* env vars\n\n# Save configuration\nconfig.set(\"new.setting\", \"value\")\nconfig.save(\"updated_config.json\")\n```\n\n#### Security Utils (`security_utils`)\nSecurity and cryptographic utilities:\n\n```python\nfrom devtools_py import security_utils\n\n# Password hashing with bcrypt\nhashed = security_utils.hash_password(\"my_secure_password\")\nis_valid = security_utils.verify_password(\"my_secure_password\", hashed)\n\n# Secure key generation\nsecret_key = security_utils.generate_secret_key(32)\nuuid = security_utils.generate_uuid()\n\n# Data hashing\nfile_hash = security_utils.hash_data(b\"file content\", \"sha256\")\n\n# JWT tokens\npayload = {\"user_id\": 123, \"role\": \"admin\"}\ntoken = security_utils.generate_jwt_token(payload, secret_key, expires_in=3600)\ndecoded = security_utils.verify_jwt_token(token, secret_key)\n\n# Input sanitization\nclean_input = security_utils.sanitize_input(\"<script>alert('xss')</script>\")\n```\n\n#### Async Utils (`async_utils`)\nBridge between sync and async code:\n\n```python\nfrom devtools_py import async_utils\nimport asyncio\n\n# Convert sync functions to async\ndef slow_sync_function(x):\n time.sleep(1)\n return x * 2\n\nasync_func = async_utils.sync_to_async(slow_sync_function)\nresult = await async_func(5) # Non-blocking\n\n# Convert async functions to sync\nasync def async_function(x):\n await asyncio.sleep(0.1)\n return x * 2\n\nsync_func = async_utils.async_to_sync(async_function)\nresult = sync_func(5) # Blocks until complete\n\n# Concurrency control\ntasks = [fetch_data(url) for url in urls]\nresults = await async_utils.gather_with_limit(5, *tasks) # Max 5 concurrent\n\n# Retry with exponential backoff\nresult = await async_utils.retry_async(\n unreliable_api_call,\n retries=3,\n delay=1.0,\n exceptions=(ConnectionError,)\n)\n\n# Async file operations\nasync_fm = async_utils.AsyncFileManager()\ncontent = await async_fm.read_text(\"large_file.txt\")\nawait async_fm.write_text(\"output.txt\", \"Hello, World!\")\n```\n\n#### Development Utils (`dev_utils`)\nDebugging and development tools:\n\n```python\nfrom devtools_py import dev_utils\n\n# Function timing and profiling\n@dev_utils.time_function\n@dev_utils.profile_memory\ndef expensive_operation():\n return [i**2 for i in range(10000)]\n\n# Pretty printing complex objects\ncomplex_data = {\"users\": [{\"id\": 1, \"nested\": {\"deep\": \"value\"}}]}\nprint(dev_utils.pretty_print_object(complex_data, max_depth=3))\n\n# Test data generation\nschema = {\"name\": str, \"age\": int, \"active\": bool}\ntest_data = dev_utils.generate_test_data(schema, count=10)\n\n# Function benchmarking\ndef method1(): return sum(range(1000))\ndef method2(): return sum([i for i in range(1000)])\n\nresults = dev_utils.benchmark_functions(method1, method2, iterations=1000)\nprint(f\"method1: {results['method1']:.4f}s avg\")\n\n# Mock HTTP server for testing\nresponses = {\n \"/api/users\": {\"users\": [{\"id\": 1, \"name\": \"John\"}]},\n \"/api/status\": {\"status\": \"ok\"}\n}\nserver = dev_utils.MockHTTPServer(responses)\nurl = server.start()\n# Make requests to url + \"/api/users\"\nserver.stop()\n```\n\n### System and Validation\n\n#### System Utils (`system_utils`)\nCross-platform system operations:\n\n```python\nfrom devtools_py import system_utils\n\n# System information\nsys_info = system_utils.get_system_info()\npython_info = system_utils.get_python_info()\n\n# Command execution with timeout\nresult = system_utils.run_command(\n [\"python\", \"--version\"], \n timeout=5.0,\n cwd=\"/path/to/directory\"\n)\n\n# Async command execution\nresult = await system_utils.run_command_async([\"ls\", \"-la\"])\n\n# Utility functions\nexecutable_path = system_utils.find_executable(\"python\")\nenv_vars = system_utils.get_env_vars(\"PYTHON_\")\nis_root = system_utils.is_admin()\nfree_port = system_utils.get_free_port(8000)\n```\n\n#### Validation Utils (`validation_utils`)\nComprehensive input validation:\n\n```python\nfrom devtools_py import validation_utils\n\n# Schema validation\nschema = {\"name\": str, \"age\": int, \"active\": bool}\ndata = {\"name\": \"John\", \"age\": 30, \"active\": True}\nerrors = validation_utils.validate_schema(data, schema)\n\n# Range and length validation\nvalidation_utils.validate_range(25, 18, 65) # True\nvalidation_utils.validate_length(\"hello\", 3, 10) # True\nvalidation_utils.validate_regex(\"test123\", r\"^\\w+\\d+$\") # True\n\n# JSON schema validation\njson_schema = {\n \"type\": \"object\",\n \"properties\": {\n \"name\": {\"type\": \"string\", \"minLength\": 1},\n \"age\": {\"type\": \"integer\", \"minimum\": 0}\n },\n \"required\": [\"name\"]\n}\nerrors = validation_utils.validate_json_schema(data, json_schema)\n\n# Rule-based validator\nvalidator = validation_utils.Validator()\nvalidator.add_rule(\"email\", lambda x: \"@\" in str(x), \"Invalid email\")\nvalidator.add_rule(\"age\", lambda x: isinstance(x, int) and x >= 0, \"Invalid age\")\nerrors = validator.validate({\"email\": \"test@example.com\", \"age\": 25})\n```\n\n#### Time Utils (`time_utils`)\nDate and time utilities:\n\n```python\nfrom devtools_py import time_utils\nfrom datetime import datetime\n\n# Flexible date parsing\ndate = time_utils.parse_date(\"2024-01-15\")\ndate = time_utils.parse_date(\"15/01/2024\", [\"%d/%m/%Y\"])\n\n# Duration formatting\nduration = time_utils.format_duration(3661) # \"1h 1m 1.0s\"\n\n# Business day calculations\nis_weekday = time_utils.is_business_day(datetime(2024, 1, 15))\nnext_workday = time_utils.next_business_day(datetime(2024, 1, 12))\n\n# Cron scheduling\nnext_run = time_utils.cron_next_run(\"0 9 * * 1-5\") # 9 AM weekdays\n\n# Timer utility\ntimer = time_utils.Timer()\ntimer.start()\n# ... do work ...\nelapsed = timer.stop()\n\n# Or as context manager\nwith time_utils.Timer() as timer:\n # ... do work ...\n pass\nprint(f\"Elapsed: {timer.elapsed():.2f}s\")\n```\n\n### CLI and Logging\n\n#### CLI Utils (`cli_utils`)\nRich terminal interfaces:\n\n```python\nfrom devtools_py import cli_utils\n\n# Interactive prompts\npassword = cli_utils.password_prompt(\"Enter password:\", confirm=True)\nselected = cli_utils.multi_select([\"option1\", \"option2\", \"option3\"])\n\n# Progress indicators\nfor item in cli_utils.progress_bar(range(100), \"Processing\"):\n # Do work with item\n pass\n\nwith cli_utils.spinner(\"Loading data...\"):\n # Long running operation\n time.sleep(2)\n\n# Colored output and tables\nprint(cli_utils.colored_text(\"Success!\", \"green\", bold=True))\nprint(cli_utils.colored_text(\"Warning\", \"yellow\"))\n\ndata = [{\"name\": \"Alice\", \"age\": 30}, {\"name\": \"Bob\", \"age\": 25}]\ntable = cli_utils.table_format(data, headers=[\"Name\", \"Age\"])\nprint(table)\n```\n\n#### Log Utils (`log_utils`)\nEnhanced logging setup:\n\n```python\nfrom devtools_py import log_utils\nimport logging\n\n# Quick logger setup\nlogger = log_utils.setup_logging(\"INFO\", to_file=\"app.log\")\nlogger = log_utils.setup_logging(\"DEBUG\", json=True, use_loguru=True)\n\n# Time logging context manager\nwith log_utils.log_time(\"database_query\"):\n # Database operation\n pass\n# Logs: \"database_query took 123.45 ms\"\n\n# Function call logging\n@log_utils.log_calls\ndef process_data(data):\n return {\"processed\": len(data)}\n\nresult = process_data([1, 2, 3])\n# Logs function calls and returns at DEBUG level\n```\n\n## CLI Interface\n\nThe toolkit also provides a command-line interface for common operations:\n\n```bash\n# String manipulation\ndevkitx string convert --to snake \"CamelCase\"\ndevkitx string validate --email \"user@example.com\"\n\n# Configuration management\ndevkitx config merge config1.json config2.yaml\n\n# Security utilities\ndevkitx security hash --algorithm sha256 \"my-data\"\ndevkitx security generate --type uuid\n\n# System information\ndevkitx system info\ndevkitx system find-executable python\n\n# Time utilities\ndevkitx time parse \"2024-01-15 14:30:00\"\ndevkitx time format-duration 3661\n```\n\n## Requirements\n\n- Python 3.10 or higher\n- Dependencies: `httpx`, `click`, `rich`, `bcrypt`, `PyJWT`\n\n## Development\n\n```bash\n# Clone the repository\ngit clone https://github.com/ladycami/devkitx.git\ncd devkitx\n\n# Install in development mode\npip install -e \".[dev]\"\n\n# Run tests\npytest\n\n# Run linting\nruff check src/\nblack --check src/\nmypy src/\n```\n\n## Contributing\n\nContributions are welcome! Please feel free to submit a Pull Request. For major changes, please open an issue first to discuss what you would like to change.\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.\n\n## Changelog\n\n### v1.0.0 (Upcoming)\n- Initial release with comprehensive utility modules\n- Full type annotations and Python 3.10+ support\n- Async utilities and HTTP client with retry logic\n- Security utilities with JWT and bcrypt support\n- Rich CLI interface with progress bars and colored output\n- Multi-format configuration management\n- Development and debugging tools\n- Comprehensive test suite with 90%+ coverage",
"bugtrack_url": null,
"license": "MIT",
"summary": "DevKitX: Comprehensive quality-of-life utilities for Python developers including JSON, HTTP, async, security, validation, and more.",
"version": "1.0.0",
"project_urls": {
"Documentation": "https://github.com/ladycami/devtools-py#readme",
"Homepage": "https://github.com/ladycami/devtools-py",
"Issues": "https://github.com/ladycami/devtools-py/issues",
"Repository": "https://github.com/ladycami/devtools-py.git"
},
"split_keywords": [
"async",
" bcrypt",
" cli",
" colored-output",
" configuration",
" cross-platform",
" debugging",
" developer-tools",
" devtools",
" env-files",
" files",
" http",
" json",
" jwt",
" logging",
" profiling",
" progress-bars",
" retry-logic",
" security",
" string-manipulation",
" system-utils",
" time-utils",
" toml",
" type-safe",
" utilities",
" validation",
" yaml"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "59b58f9357667a5e8e37c9d35f565214a796d292491d2f93a6e583713e819240",
"md5": "b0bf399f15157b6309b7a260ca758c0f",
"sha256": "a5c2d6f37c5e36091be82a34d645d719a48ff1163846e972d6c92bc7d360816f"
},
"downloads": -1,
"filename": "devkitx-1.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "b0bf399f15157b6309b7a260ca758c0f",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 53983,
"upload_time": "2025-09-16T00:36:29",
"upload_time_iso_8601": "2025-09-16T00:36:29.757141Z",
"url": "https://files.pythonhosted.org/packages/59/b5/8f9357667a5e8e37c9d35f565214a796d292491d2f93a6e583713e819240/devkitx-1.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "19ca29ca4085b1401fb24b7ee05d96b3c743df97430bbbd7d73bd1b9a2f030c8",
"md5": "5e06eca59b97cbb43f771690b38896cd",
"sha256": "0aa33811957b42d1a8d08c6bafb5dd61a7b80910107f1a5cc362e61ae3d60527"
},
"downloads": -1,
"filename": "devkitx-1.0.0.tar.gz",
"has_sig": false,
"md5_digest": "5e06eca59b97cbb43f771690b38896cd",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 89939,
"upload_time": "2025-09-16T00:36:31",
"upload_time_iso_8601": "2025-09-16T00:36:31.335361Z",
"url": "https://files.pythonhosted.org/packages/19/ca/29ca4085b1401fb24b7ee05d96b3c743df97430bbbd7d73bd1b9a2f030c8/devkitx-1.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-16 00:36:31",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ladycami",
"github_project": "devtools-py#readme",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "devkitx"
}
JSON
