utilix-sdk

418 developer utility functions for Python: runs entirely locally, no API key required.

Installation

pip install utilix-sdk

Requires Python 3.11 or later.

Quick Start

Encoding

from utilix.tools.encoding import encode_base64, decode_base64

result = encode_base64("hello world")
# {"ok": True, "output": "aGVsbG8gd29ybGQ=", "inputBytes": 11, "outputChars": 16}

result = decode_base64("aGVsbG8gd29ybGQ=")
# {"ok": True, "output": "hello world", "outputBytes": 11}

Hashing

from utilix.tools.hashing import hash_all, hash_one

result = hash_all("my-secret")
# Returns MD5, SHA-1, SHA-256, SHA-384, SHA-512 digests in one call

sha256 = hash_one("SHA-256", "my-secret")
# {"ok": True, "algorithm": "SHA-256", "hex": "...", "bits": 256}

JSON Tools

from utilix.tools.json_tools import format_json, minify_json, yaml_to_json

pretty = format_json('{"name":"utilix","version":"0.1.0"}', indent=2)
# {"status": "valid", "output": "{\n  \"name\": \"utilix\", ...", ...}

minified = minify_json('{\n  "a": 1,\n  "b": 2\n}')
# {"ok": True, "output": "{\"a\":1,\"b\":2}", ...}

as_json = yaml_to_json("name: utilix\nversion: 0.1.0")
# {"ok": True, "output": "{\"name\": \"utilix\", \"version\": \"0.1.0\"}"}

Color

from utilix.tools.color import hex_to_rgb, check_contrast, generate_palette

rgb = hex_to_rgb("#3B82F6")
# {"ok": True, "r": 59, "g": 130, "b": 246}

contrast = check_contrast("#FFFFFF", "#3B82F6")
# {"ratio": 3.94, "aa_normal": False, "aa_large": True, "aaa_normal": False, ...}

palette = generate_palette("#3B82F6", scheme="complementary")
# Returns list of hex colors forming a complementary palette

Media

from utilix.tools.media import compress_image, convert_image, read_image_info, read_exif_data, read_pdf_metadata, read_wav_info, read_id3_tags, read_ico_info

with open("photo.jpg", "rb") as f:
    image_bytes = f.read()

result = compress_image(image_bytes, quality=75, format="JPEG")
# {"ok": True, "output": bytes, "original_size": 204800, "compressed_size": 61440, "ratio": 0.3}

converted = convert_image(image_bytes, target_format="WEBP")
# {"ok": True, "output": bytes, "format": "WEBP"}

# Read format, dimensions, bit depth, and alpha channel straight from file
# bytes: no decoding, no Pillow required. Supports PNG, JPEG, GIF, WebP, BMP.
info = read_image_info(image_bytes)
# {"ok": True, "format": "jpeg", "width": 1920, "height": 1080, "bitDepth": 8, "colorType": "rgb"}

# Read camera make/model, orientation, timestamps, exposure settings, and
# GPS coordinates directly from a JPEG's EXIF data. JPEG only.
exif = read_exif_data(image_bytes)
# {"ok": True, "make": "Canon", "model": "EOS R5", "exposureTime": "1/125", "fNumber": 2.8, ...}

# Read title, author, dates, page count, and encryption flag from a PDF's
# trailer/Info dictionary: no PDF rendering library required.
with open("report.pdf", "rb") as f:
    pdf_metadata = read_pdf_metadata(f.read())
# {"ok": True, "version": "1.7", "pageCount": 12, "title": "Q3 Report", "author": "Jane Doe", ...}

# Read sample rate, channels, bit depth, and duration from a WAV file's
# RIFF/fmt/data chunk headers: no audio library required.
with open("recording.wav", "rb") as f:
    wav_info = read_wav_info(f.read())
# {"ok": True, "audioFormat": 1, "audioFormatLabel": "PCM", "channels": 2, "sampleRate": 44100, "bitsPerSample": 16, "durationSeconds": 12.4, ...}

# Read title, artist, album, year, genre, comment, and track number from an
# MP3's ID3 tags. Prefers ID3v2.3/2.4 text frames, falls back to the classic
# 128-byte ID3v1/1.1 trailer.
with open("track.mp3", "rb") as f:
    id3_tags = read_id3_tags(f.read())
# {"ok": True, "version": "ID3v2.3.0", "title": "Track Name", "artist": "Artist Name", "genre": "Rock", ...}

# Read how many images a .ico file embeds and each one's dimensions, color
# depth, and size directly from its ICONDIR/ICONDIRENTRY header table.
with open("favicon.ico", "rb") as f:
    ico_info = read_ico_info(f.read())
# {"ok": True, "imageCount": 3, "images": [{"width": 16, "height": 16, "bitCount": 32, ...}, ...]}

CSS

from utilix.tools.css import generate_gradient, calc_specificity, minify_css

gradient = generate_gradient({
    "type": "linear",
    "angle": 135,
    "stops": [{"color": "#667eea", "position": 0}, {"color": "#764ba2", "position": 100}]
})
# "linear-gradient(135deg, #667eea 0%, #764ba2 100%)"

specificity = calc_specificity("#nav .item:hover")
# {"score": (0, 1, 1, 1), "display": "0,1,1,1", "explanation": [...]}

minified = minify_css("body {\n  margin: 0;\n  padding: 0;\n}")
# {"ok": True, "output": "body{margin:0;padding:0}", "saved_bytes": 14}

Time Tools

from utilix.tools.time_tools import from_unix, diff_dates, get_next_runs

parsed = from_unix(1735689600)
# {"ok": True, "iso": "2025-01-01T00:00:00+00:00", "relative": "6 months ago", ...}

delta = diff_dates("2024-01-01", "2024-12-31")
# {"ok": True, "days": 365, "months": 12, "human": "12 months"}

schedule = get_next_runs("0 9 * * MON-FRI", count=5)
# Next 5 weekday 9am runs as ISO strings

Network

from utilix.tools.network import ip_to_decimal, cidr_info, is_valid_ipv4

decimal = ip_to_decimal("192.168.1.1")
# {"ok": True, "output": 3232235777}

subnet = cidr_info("10.0.0.0/24")
# {"ok": True, "network": "10.0.0.0", "broadcast": "10.0.0.255",
#  "hosts": 254, "netmask": "255.255.255.0", ...}

print(is_valid_ipv4("256.0.0.1"))  # False

from utilix.tools.network import parse_har, validate_sitemap, validate_robots_txt

# Parse a DevTools .har network export into entries + summary stats
with open("network.har") as f:
    result = parse_har(f.read())
# {"ok": True, "output": {"entries": [...], "summary": {"totalRequests": 12, ...}}}

# Validate a sitemap.xml (or sitemap index) against the sitemaps.org protocol
validate_sitemap('<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"><url><loc>https://example.com/</loc></url></urlset>')
# {"ok": True, "output": {"type": "urlset", "urlCount": 1, "entries": [...], "issues": [...], "valid": True}}

# Validate a robots.txt file: User-agent groups, rules, and syntax mistakes
validate_robots_txt("User-agent: *\nDisallow: /admin\nSitemap: https://example.com/sitemap.xml")
# {"ok": True, "output": {"groups": [...], "sitemaps": [...], "issues": [...], "valid": True}}

from utilix.tools.network import parse_user_agent

# Parse a browser User-Agent string into browser, engine, OS, and device type
parse_user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
# {"ok": True, "output": {"browser": {"name": "Chrome", "version": "120.0.0.0"},
#  "engine": {"name": "Blink", "version": "120.0.0.0"}, "os": {"name": "Windows", "version": "10"},
#  "device": {"type": "desktop"}, "raw": "..."}}

from utilix.tools.network import build_cache_control

# Build and explain a Cache-Control response header from directives
build_cache_control({"visibility": "public", "maxAge": 3600, "mustRevalidate": True})
# {"ok": True, "output": {"header": "public, max-age=3600, must-revalidate", "directives": [...], "warnings": []}}

Modules

Surface A vs Surface B

Surface A: this package (utilix-sdk)

Everything in this package runs locally in your Python process. There are no network calls for the core utilities (DNS lookup and IP geolocation are the only exceptions, and both hit public free APIs). No account, no API key, no rate limits.

pip install utilix-sdk

Ideal for: scripts, CI pipelines, offline environments, CLIs, and any situation where you want deterministic, zero-cost utility functions.

REST API (api.utilix.tech/v1)

The same 140+ tools are also available as a hosted REST API at https://api.utilix.tech/v1. This surface requires an API key and is subject to rate limits and pricing tiers.

curl -X POST https://api.utilix.tech/v1/tools/hash \
  -H "Authorization: Bearer $UTILIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": "hello world", "algorithm": "sha256"}'

• Free: 1,000 requests/day: no credit card required
• Pro: 10,000 requests/day: $9/month
• Try it live at utilix.tech/api: no signup needed for the first 10 endpoints
• Get your API key at utilix.tech/dashboard

Ideal for: polyglot teams, environments where installing Python packages is not possible, and browser-based tooling that needs a backend.

Contributing

The source for this package is maintained in a private monorepo; this repository holds examples, quickstarts, and the issue tracker. Found a bug or want to request a tool? Open an issue at github.com/utilix-tech/utilix-sdk/issues or email hello@utilix.tech.

Publishing to PyPI

Build the distribution

python -m build
# Produces dist/utilix_sdk-x.y.z.tar.gz and dist/utilix_sdk-x.y.z-py3-none-any.whl

Test on TestPyPI first

python -m twine upload --repository testpypi dist/*
# Install from TestPyPI to verify
pip install --index-url https://test.pypi.org/simple/ utilix-sdk

Publish to PyPI

python -m twine upload dist/*

GitHub Actions with OIDC trusted publisher (recommended)

Store no tokens. Configure a trusted publisher on PyPI (Settings > Publishing > Add a new publisher) and use the official PyPA action:

# .github/workflows/publish.yml
name: Publish to PyPI

on:
  push:
    tags:
      - "v*"

jobs:
  publish:
    runs-on: ubuntu-latest
    permissions:
      id-token: write  # Required for OIDC

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Build
        run: |
          pip install build
          python -m build

      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        # No api-token needed: OIDC trusted publisher handles auth

Tag a release (git tag v0.2.0 && git push --tags) and the workflow publishes automatically with no stored credentials.

License

MIT. See LICENSE for the full text.