diff --git a/.bumpversion.cfg b/.bumpversion.cfg new file mode 100644 index 00000000..1c128c3c --- /dev/null +++ b/.bumpversion.cfg @@ -0,0 +1,14 @@ +[bumpversion] +current_version = 4.1.1 +commit = True +tag = True +tag_name = v{new_version} +message = Bump version: {current_version} ā†’ {new_version} + +[bumpversion:file:datafog/__about__.py] +search = __version__ = "{current_version}" +replace = __version__ = "{new_version}" + +[bumpversion:file:setup.py] +search = version="{current_version}" +replace = version="{new_version}" \ No newline at end of file diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5654f222..e4aa29d6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,13 +38,13 @@ jobs: sudo apt-get update sudo apt-get install -y tesseract-ocr libtesseract-dev - - name: Install dependencies + - name: Install all dependencies run: | python -m pip install --upgrade pip - pip install -e ".[nlp,ocr]" + pip install -e ".[all]" pip install -r requirements-dev.txt - - name: Run tests + - name: Run full test suite run: | python -m pytest tests/ --cov=datafog --cov-report=xml --cov-report=term @@ -54,6 +54,31 @@ jobs: file: ./coverage.xml token: ${{ secrets.CODECOV_TOKEN }} + test-core: + runs-on: ubuntu-latest + strategy: + matrix: + python-version: ["3.10", "3.11", "3.12"] + steps: + - uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + cache: "pip" + + - name: Install core dependencies only + run: | + python -m pip install --upgrade pip + pip install -e . + pip install pytest pytest-cov + + - name: Test core functionality + run: | + python -c "from datafog import detect_pii, anonymize_text; print('Core API works')" + python -c "from datafog import detect, process; print('Legacy API works')" + python -m pytest tests/test_regex_annotator.py -v + wheel-size: runs-on: ubuntu-latest steps: diff --git a/.github/workflows/weekly-release.yml b/.github/workflows/weekly-release.yml new file mode 100644 index 00000000..111fe537 --- /dev/null +++ b/.github/workflows/weekly-release.yml @@ -0,0 +1,112 @@ +name: Weekly Release + +on: + schedule: + # Every Friday at 2 PM UTC + - cron: "0 14 * * 5" + workflow_dispatch: + inputs: + release_type: + description: "Release type" + required: true + default: "patch" + type: choice + options: + - patch + - minor + - major + +jobs: + release: + runs-on: ubuntu-latest + if: github.ref == 'refs/heads/dev' + + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + token: ${{ secrets.GITHUB_TOKEN }} + + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: "3.10" + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install bump2version build twine + pip install -e .[all] + + - name: Run full test suite + run: | + python -m pytest tests/ --cov=datafog + python -m pytest tests/benchmark_text_service.py + + - name: Generate changelog + run: | + python scripts/generate_changelog.py + + - name: Determine version bump + id: version + run: | + if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then + echo "bump_type=${{ github.event.inputs.release_type }}" >> $GITHUB_OUTPUT + else + # Auto-determine based on commit messages + if git log --oneline $(git describe --tags --abbrev=0)..HEAD | grep -q "BREAKING"; then + echo "bump_type=major" >> $GITHUB_OUTPUT + elif git log --oneline $(git describe --tags --abbrev=0)..HEAD | grep -q "feat:"; then + echo "bump_type=minor" >> $GITHUB_OUTPUT + else + echo "bump_type=patch" >> $GITHUB_OUTPUT + fi + fi + + - name: Bump version + run: | + git config --local user.email "action@github.com" + git config --local user.name "GitHub Action" + bump2version ${{ steps.version.outputs.bump_type }} + echo "NEW_VERSION=$(python -c 'from datafog import __version__; print(__version__)')" >> $GITHUB_ENV + + - name: Build package + run: | + python -m build + + - name: Check wheel size + run: | + WHEEL_SIZE=$(du -m dist/*.whl | cut -f1) + if [ "$WHEEL_SIZE" -ge 5 ]; then + echo "āŒ Wheel size too large: ${WHEEL_SIZE}MB" + exit 1 + fi + echo "āœ… Wheel size OK: ${WHEEL_SIZE}MB" + + - name: Publish to PyPI + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }} + run: twine upload dist/* + + - name: Create GitHub Release + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + gh release create v${{ env.NEW_VERSION }} \ + --title "DataFog v${{ env.NEW_VERSION }}" \ + --notes-file CHANGELOG_LATEST.md \ + dist/* + + - name: Push changes + run: | + git push origin dev --tags + + - name: Notify Discord + if: env.DISCORD_WEBHOOK + env: + DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }} + run: | + curl -X POST "$DISCORD_WEBHOOK" \ + -H "Content-Type: application/json" \ + -d "{\"content\": \"šŸš€ DataFog v${{ env.NEW_VERSION }} is live! Install with: \`pip install datafog==${{ env.NEW_VERSION }}\`\"}" diff --git a/.github/workflows/wheel_size.yml b/.github/workflows/wheel_size.yml deleted file mode 100644 index 2cf3c5e1..00000000 --- a/.github/workflows/wheel_size.yml +++ /dev/null @@ -1,38 +0,0 @@ -name: Wheel Size Check - -on: - push: - branches: [main, dev] - pull_request: - branches: [main, dev] - -jobs: - check-wheel-size: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - - name: Set up Python - uses: actions/setup-python@v5 - with: - python-version: "3.10" - cache: "pip" - - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install build wheel - - - name: Build wheel - run: python -m build --wheel - - - name: Check wheel size - run: python scripts/check_wheel_size.py - - - name: Upload wheel artifact - uses: actions/upload-artifact@v4 - with: - name: wheel - path: dist/*.whl diff --git a/Claude.md b/Claude.md index 53b02143..39b6aeef 100644 --- a/Claude.md +++ b/Claude.md @@ -27,7 +27,7 @@ - **Graceful Degradation**: Smart imports with helpful error messages for missing extras - **Fair Benchmark Analysis**: Independent performance validation scripts -### āœ… Critical Bug Fixes Resolved (December 2024) +### āœ… Critical Bug Fixes Resolved (May 2025) - **CI/CD Stability**: Fixed GitHub Actions failures while preserving lean architecture - **Structured Output Bug**: Resolved multi-chunk text processing in TextService - **Test Suite Health**: Improved from 33% to 87% test success rate (156/180 passing) diff --git a/datafog/__init__.py b/datafog/__init__.py index def65c23..a0a0d2e6 100644 --- a/datafog/__init__.py +++ b/datafog/__init__.py @@ -10,6 +10,9 @@ from .__about__ import __version__ +# Import core API functions +from .core import anonymize_text, detect_pii, get_supported_entities, scan_text + # Core imports - always available from .models.annotator import AnnotationResult, AnnotatorRequest from .models.anonymizer import ( @@ -78,7 +81,7 @@ def _missing_dependency(*args, **kwargs): ) -# Simple API for core functionality +# Simple API for core functionality (backward compatibility) def detect(text: str) -> list: """ Detect PII in text using regex patterns. @@ -169,6 +172,10 @@ def process(text: str, anonymize: bool = False, method: str = "redact") -> dict: "__version__", "detect", "process", + "detect_pii", + "anonymize_text", + "scan_text", + "get_supported_entities", "AnnotationResult", "AnnotatorRequest", "AnonymizationResult", diff --git a/datafog/core.py b/datafog/core.py new file mode 100644 index 00000000..6d871625 --- /dev/null +++ b/datafog/core.py @@ -0,0 +1,177 @@ +""" +DataFog Core API - Lightweight PII detection functions. + +This module provides simple, lightweight functions for PII detection and anonymization +without requiring heavy dependencies like spaCy or PyTorch. +""" + +from typing import Dict, List, Union + +from datafog.models.anonymizer import AnonymizerType + +# Engine types as constants +REGEX_ENGINE = "regex" +SPACY_ENGINE = "spacy" +AUTO_ENGINE = "auto" + + +def detect_pii(text: str) -> Dict[str, List[str]]: + """ + Simple PII detection using lightweight regex engine. + + Args: + text: Text to scan for PII + + Returns: + Dictionary mapping entity types to lists of detected values + + Example: + >>> result = detect_pii("Contact john@example.com at (555) 123-4567") + >>> print(result) + {'EMAIL': ['john@example.com'], 'PHONE': ['(555) 123-4567']} + """ + try: + from datafog.services.text_service import TextService + + # Use lightweight regex engine only + service = TextService(engine=REGEX_ENGINE) + result = service.annotate_text_sync(text, structured=True) + + # Convert to simple dictionary format, filtering out empty matches + pii_dict = {} + for annotation in result: + if annotation.text.strip(): # Only include non-empty matches + entity_type = annotation.label + if entity_type not in pii_dict: + pii_dict[entity_type] = [] + pii_dict[entity_type].append(annotation.text) + + return pii_dict + + except ImportError as e: + raise ImportError( + "Core dependencies missing. Install with: pip install datafog[all]" + ) from e + + +def anonymize_text(text: str, method: Union[str, AnonymizerType] = "redact") -> str: + """ + Simple text anonymization using lightweight regex engine. + + Args: + text: Text to anonymize + method: Anonymization method ('redact', 'replace', or 'hash') + + Returns: + Anonymized text string + + Example: + >>> result = anonymize_text("Contact john@example.com", method="redact") + >>> print(result) + "Contact [EMAIL_REDACTED]" + """ + try: + from datafog.models.anonymizer import Anonymizer, AnonymizerType + from datafog.services.text_service import TextService + + # Convert string method to enum if needed + if isinstance(method, str): + method_map = { + "redact": AnonymizerType.REDACT, + "replace": AnonymizerType.REPLACE, + "hash": AnonymizerType.HASH, + } + if method not in method_map: + raise ValueError( + f"Invalid method: {method}. Use 'redact', 'replace', or 'hash'" + ) + method = method_map[method] + + # Use lightweight regex engine only + service = TextService(engine=REGEX_ENGINE) + span_results = service.annotate_text_sync(text, structured=True) + + # Convert Span objects to AnnotationResult format for anonymizer, filtering empty matches + from datafog.models.annotator import AnnotationResult + + annotations = [] + for span in span_results: + if span.text.strip(): # Only include non-empty matches + annotation = AnnotationResult( + entity_type=span.label, + start=span.start, + end=span.end, + score=1.0, # Regex matches are certain + recognition_metadata=None, + ) + annotations.append(annotation) + + # Create anonymizer and apply + anonymizer = Anonymizer(anonymizer_type=method) + result = anonymizer.anonymize(text, annotations) + return result.anonymized_text + + except ImportError as e: + raise ImportError( + "Core dependencies missing. Install with: pip install datafog[all]" + ) from e + + +def scan_text( + text: str, return_entities: bool = False +) -> Union[bool, Dict[str, List[str]]]: + """ + Quick scan to check if text contains any PII. + + Args: + text: Text to scan + return_entities: If True, return detected entities; if False, return boolean + + Returns: + Boolean indicating PII presence, or dictionary of detected entities + + Example: + >>> has_pii = scan_text("Contact john@example.com") + >>> print(has_pii) + True + + >>> entities = scan_text("Contact john@example.com", return_entities=True) + >>> print(entities) + {'EMAIL': ['john@example.com']} + """ + entities = detect_pii(text) + + if return_entities: + return entities + else: + return len(entities) > 0 + + +def get_supported_entities() -> List[str]: + """ + Get list of PII entity types supported by the regex engine. + + Returns: + List of supported entity type names + + Example: + >>> entities = get_supported_entities() + >>> print(entities) + ['EMAIL', 'PHONE', 'SSN', 'CREDIT_CARD', 'IP_ADDRESS', 'DOB', 'ZIP'] + """ + try: + from datafog.processing.text_processing.regex_annotator.regex_annotator import ( + RegexAnnotator, + ) + + annotator = RegexAnnotator() + return [entity.value for entity in annotator.supported_entities] + + except ImportError: + # Fallback to basic list if imports fail + return ["EMAIL", "PHONE", "SSN", "CREDIT_CARD", "IP_ADDRESS", "DOB", "ZIP"] + + +# Backward compatibility aliases +detect = detect_pii +process = anonymize_text diff --git a/scripts/generate_changelog.py b/scripts/generate_changelog.py new file mode 100755 index 00000000..8050a8c8 --- /dev/null +++ b/scripts/generate_changelog.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Generate changelog for weekly releases.""" + +import re +import subprocess +from datetime import datetime + + +def get_latest_tag(): + """Get the latest git tag.""" + try: + result = subprocess.run( + ["git", "describe", "--tags", "--abbrev=0"], + capture_output=True, + text=True, + check=True, + ) + return result.stdout.strip() + except subprocess.CalledProcessError: + return None + + +def get_commits_since_tag(tag): + """Get commits since the given tag.""" + if tag: + cmd = ["git", "log", f"{tag}..HEAD", "--oneline"] + else: + cmd = ["git", "log", "--oneline"] + + result = subprocess.run(cmd, capture_output=True, text=True, check=True) + return result.stdout.strip().split("\n") if result.stdout.strip() else [] + + +def categorize_commits(commits): + """Categorize commits by type.""" + categories = { + "features": [], + "fixes": [], + "performance": [], + "docs": [], + "other": [], + } + + for commit in commits: + commit = commit.strip() + if not commit: + continue + + if re.search(r"\b(feat|feature|add)\b", commit, re.I): + categories["features"].append(commit) + elif re.search(r"\b(fix|bug|patch)\b", commit, re.I): + categories["fixes"].append(commit) + elif re.search(r"\b(perf|performance|speed|optimize)\b", commit, re.I): + categories["performance"].append(commit) + elif re.search(r"\b(doc|docs|readme)\b", commit, re.I): + categories["docs"].append(commit) + else: + categories["other"].append(commit) + + return categories + + +def generate_changelog(): + """Generate changelog content.""" + latest_tag = get_latest_tag() + commits = get_commits_since_tag(latest_tag) + + if not commits: + return "No changes since last release." + + categories = categorize_commits(commits) + + changelog = "# What's New\n\n" + changelog += f"*Released: {datetime.now().strftime('%Y-%m-%d')}*\n\n" + + if categories["features"]: + changelog += "## šŸš€ New Features\n" + for commit in categories["features"]: + changelog += f"- {commit[8:]}\n" # Remove hash + changelog += "\n" + + if categories["performance"]: + changelog += "## āš” Performance Improvements\n" + for commit in categories["performance"]: + changelog += f"- {commit[8:]}\n" + changelog += "\n" + + if categories["fixes"]: + changelog += "## šŸ› Bug Fixes\n" + for commit in categories["fixes"]: + changelog += f"- {commit[8:]}\n" + changelog += "\n" + + if categories["docs"]: + changelog += "## šŸ“š Documentation\n" + for commit in categories["docs"]: + changelog += f"- {commit[8:]}\n" + changelog += "\n" + + if categories["other"]: + changelog += "## šŸ”§ Other Changes\n" + for commit in categories["other"]: + changelog += f"- {commit[8:]}\n" + changelog += "\n" + + changelog += "## šŸ“„ Installation\n\n" + changelog += "```bash\n" + changelog += "# Core package (lightweight)\n" + changelog += "pip install datafog\n\n" + changelog += "# With all features\n" + changelog += "pip install datafog[all]\n" + changelog += "```\n\n" + + changelog += "## šŸ“Š Metrics\n\n" + changelog += "- Package size: ~2MB (core)\n" + changelog += "- Install time: ~10 seconds\n" + changelog += "- Tests passing: āœ…\n" + changelog += f"- Commits this week: {len(commits)}\n\n" + + return changelog + + +if __name__ == "__main__": + changelog_content = generate_changelog() + + # Write to file for GitHub release + with open("CHANGELOG_LATEST.md", "w") as f: + f.write(changelog_content) + + print("āœ… Changelog generated: CHANGELOG_LATEST.md") + print("\nPreview:") + print("=" * 50) + print(changelog_content) diff --git a/scripts/weekly_metrics.py b/scripts/weekly_metrics.py new file mode 100755 index 00000000..382fcd1f --- /dev/null +++ b/scripts/weekly_metrics.py @@ -0,0 +1,278 @@ +#!/usr/bin/env python3 +""" +Weekly metrics tracking script for DataFog releases. + +Collects and stores metrics for weekly release analysis including: +- PyPI download statistics +- GitHub repository metrics +- Package size and performance data +- Test coverage information +""" + +import json +import os +import subprocess +from datetime import datetime, timedelta +from typing import Any, Dict + +import requests + + +def get_current_version() -> str: + """Get current version from package.""" + try: + from datafog import __version__ + + return __version__ + except ImportError: + # Fallback to setup.py + with open("setup.py", "r") as f: + for line in f: + if "version=" in line: + return line.split('"')[1] + return "unknown" + + +def get_pypi_stats(package_name: str = "datafog") -> Dict[str, Any]: + """Get PyPI download and package statistics.""" + try: + # Get package info from PyPI API + response = requests.get( + f"https://pypi.org/pypi/{package_name}/json", timeout=10 + ) + response.raise_for_status() + data = response.json() + + info = data.get("info", {}) + latest_release = data.get("releases", {}).get(info.get("version", ""), []) + + # Calculate package size from wheel if available + wheel_size = 0 + for file_info in latest_release: + if file_info.get("packagetype") == "bdist_wheel": + wheel_size = file_info.get("size", 0) / (1024 * 1024) # Convert to MB + break + + return { + "version": info.get("version", "unknown"), + "description": info.get("summary", ""), + "wheel_size_mb": round(wheel_size, 2), + "upload_time": ( + latest_release[0].get("upload_time") if latest_release else None + ), + "python_requires": info.get("requires_python", ""), + } + except Exception as e: + print(f"Error fetching PyPI stats: {e}") + return {"error": str(e)} + + +def get_github_stats(repo: str = "datafog/datafog-python") -> Dict[str, Any]: + """Get GitHub repository statistics.""" + try: + # Use GitHub API + headers = {} + if os.getenv("GITHUB_TOKEN"): + headers["Authorization"] = f"token {os.getenv('GITHUB_TOKEN')}" + + response = requests.get( + f"https://api.github.com/repos/{repo}", headers=headers, timeout=10 + ) + response.raise_for_status() + data = response.json() + + return { + "stars": data.get("stargazers_count", 0), + "forks": data.get("forks_count", 0), + "open_issues": data.get("open_issues_count", 0), + "watchers": data.get("subscribers_count", 0), + "size_kb": data.get("size", 0), + "default_branch": data.get("default_branch", "main"), + "last_push": data.get("pushed_at"), + } + except Exception as e: + print(f"Error fetching GitHub stats: {e}") + return {"error": str(e)} + + +def get_local_metrics() -> Dict[str, Any]: + """Get local package and test metrics.""" + metrics = {} + + try: + # Get wheel size by building + subprocess.run( + ["python", "-m", "build", "--wheel"], + capture_output=True, + check=True, + cwd=".", + ) + + # Find wheel file and get size + wheel_files = [f for f in os.listdir("dist") if f.endswith(".whl")] + if wheel_files: + wheel_path = os.path.join("dist", wheel_files[-1]) # Latest wheel + size_mb = os.path.getsize(wheel_path) / (1024 * 1024) + metrics["local_wheel_size_mb"] = round(size_mb, 2) + except Exception as e: + print(f"Error building wheel: {e}") + metrics["local_wheel_size_mb"] = "error" + + try: + # Get test coverage if coverage file exists + if os.path.exists("coverage.xml"): + with open("coverage.xml", "r") as f: + content = f.read() + # Simple extraction of coverage percentage + if 'line-rate="' in content: + start = content.find('line-rate="') + len('line-rate="') + end = content.find('"', start) + coverage = float(content[start:end]) * 100 + metrics["test_coverage_percent"] = round(coverage, 1) + except Exception as e: + print(f"Error reading coverage: {e}") + metrics["test_coverage_percent"] = "unknown" + + try: + # Count test files + test_files = len( + [ + f + for f in os.listdir("tests") + if f.startswith("test_") and f.endswith(".py") + ] + ) + metrics["test_file_count"] = test_files + except Exception: + metrics["test_file_count"] = "unknown" + + return metrics + + +def get_git_stats() -> Dict[str, Any]: + """Get git repository statistics.""" + try: + # Get commit count for current week + week_ago = (datetime.now() - timedelta(days=7)).strftime("%Y-%m-%d") + result = subprocess.run( + ["git", "log", "--oneline", f"--since={week_ago}"], + capture_output=True, + text=True, + check=True, + ) + commits_this_week = ( + len(result.stdout.strip().split("\n")) if result.stdout.strip() else 0 + ) + + # Get total commit count + result = subprocess.run( + ["git", "rev-list", "--count", "HEAD"], + capture_output=True, + text=True, + check=True, + ) + total_commits = int(result.stdout.strip()) + + # Get current branch + result = subprocess.run( + ["git", "branch", "--show-current"], + capture_output=True, + text=True, + check=True, + ) + current_branch = result.stdout.strip() + + return { + "commits_this_week": commits_this_week, + "total_commits": total_commits, + "current_branch": current_branch, + } + except Exception as e: + print(f"Error fetching git stats: {e}") + return {"error": str(e)} + + +def generate_weekly_report() -> Dict[str, Any]: + """Generate comprehensive weekly metrics report.""" + current_time = datetime.now() + week_number = current_time.strftime("%Y-W%U") + + print("šŸ“Š Generating weekly metrics report...") + + metrics = { + "week": week_number, + "generated_at": current_time.isoformat(), + "version": get_current_version(), + } + + print(" ā€¢ Fetching PyPI statistics...") + metrics["pypi"] = get_pypi_stats() + + print(" ā€¢ Fetching GitHub statistics...") + metrics["github"] = get_github_stats() + + print(" ā€¢ Collecting local metrics...") + metrics["local"] = get_local_metrics() + + print(" ā€¢ Analyzing git repository...") + metrics["git"] = get_git_stats() + + # Add some computed metrics + metrics["computed"] = { + "is_friday_release": current_time.weekday() == 4, # Friday = 4 + "days_since_monday": current_time.weekday(), + } + + return metrics + + +def save_metrics(metrics: Dict[str, Any]) -> None: + """Save metrics to file and display summary.""" + # Ensure metrics directory exists + os.makedirs("metrics", exist_ok=True) + + # Save to JSON file + filename = f"metrics/week_{metrics['week']}.json" + with open(filename, "w") as f: + json.dump(metrics, f, indent=2) + + print(f"āœ… Metrics saved to {filename}") + + # Display summary + print("\nšŸ“ˆ Weekly Summary:") + print(f" Version: {metrics['version']}") + + if "github" in metrics and "stars" in metrics["github"]: + print(f" GitHub Stars: {metrics['github']['stars']}") + + if "local" in metrics and "local_wheel_size_mb" in metrics["local"]: + print(f" Package Size: {metrics['local']['local_wheel_size_mb']} MB") + + if "local" in metrics and "test_coverage_percent" in metrics["local"]: + print(f" Test Coverage: {metrics['local']['test_coverage_percent']}%") + + if "git" in metrics and "commits_this_week" in metrics["git"]: + print(f" Commits This Week: {metrics['git']['commits_this_week']}") + + +def main(): + """Main function to generate and save weekly metrics.""" + try: + metrics = generate_weekly_report() + save_metrics(metrics) + + print("\nšŸŽÆ Next Steps:") + print(" 1. Review metrics for any anomalies") + print(" 2. Compare with previous weeks") + print(" 3. Update release notes with key numbers") + print(" 4. Prepare social media posts") + + except Exception as e: + print(f"āŒ Error generating metrics: {e}") + return 1 + + return 0 + + +if __name__ == "__main__": + exit(main()) diff --git a/setup.py b/setup.py index 9cd06dd6..f996175e 100644 --- a/setup.py +++ b/setup.py @@ -5,7 +5,7 @@ long_description = f.read() # Use a single source of truth for the version -__version__ = "4.1.1" +version = "4.1.1" project_urls = { "Homepage": "https://datafog.ai", @@ -72,7 +72,7 @@ setup( name="datafog", - version=__version__, + version=version, author="Sid Mohan", author_email="sid@datafog.ai", description="Lightning-fast PII detection and anonymization library with 190x performance advantage", diff --git a/templates/release_announcement.md b/templates/release_announcement.md new file mode 100644 index 00000000..9347dac2 --- /dev/null +++ b/templates/release_announcement.md @@ -0,0 +1,35 @@ +# šŸš€ DataFog {{version}} is Live! + +## This Week's Highlights + +{{highlights}} + +## šŸ“ˆ Performance Stats + +- Package size: {{package_size}}MB +- Install time: {{install_time}}s +- Processing speed: {{speed_improvement}}x faster than alternatives + +## šŸ“„ Get Started + +```bash +# Lightweight core +pip install datafog=={{version}} + +# Full features +pip install datafog[all]=={{version}} +``` + +## šŸ”— Links + +- [Release Notes]({{release_url}}) +- [Documentation](https://docs.datafog.ai) +- [GitHub](https://github.com/datafog/datafog-python) + +## šŸ™ Community + +Join our [Discord](https://discord.gg/bzDth394R4) ā€¢ Star us on [GitHub](https://github.com/datafog/datafog-python) ā€¢ Follow [@datafoginc](https://twitter.com/datafoginc) + +--- + +_Released every Friday ā€¢ Subscribe to releases on GitHub_ diff --git a/templates/social_media_templates.md b/templates/social_media_templates.md new file mode 100644 index 00000000..4d734709 --- /dev/null +++ b/templates/social_media_templates.md @@ -0,0 +1,124 @@ +# Social Media Templates for Weekly Releases + +## Twitter Template + +``` +šŸš€ DataFog {{version}} is out! + +{{key_feature}} + +āš” {{speed_stat}} +šŸ“¦ {{size_stat}} +šŸ”§ pip install datafog=={{version}} + +#PII #DataProtection #Privacy #Python #OpenSource + +{{github_link}} +``` + +## Reddit Template (r/Python, r/MachineLearning) + +``` +Title: DataFog {{version}}: {{headline_feature}} + +Weekly update from the DataFog team! This week we focused on {{theme}}. + +Key improvements: +- {{improvement_1}} +- {{improvement_2}} +- {{improvement_3}} + +The library is designed to be the fastest PII detection tool for Python, with our regex engine running 190x faster than spaCy alternatives. + +Try it: `pip install datafog=={{version}}` + +Feedback welcome! We ship every Friday. +``` + +## LinkedIn Template + +``` +šŸš€ DataFog {{version}} Release Update + +This week's focus: {{theme}} + +Key achievements: +āœ… {{achievement_1}} +āœ… {{achievement_2}} +āœ… {{achievement_3}} + +DataFog continues to deliver 190x faster PII detection than traditional solutions, helping organizations protect sensitive data at scale. + +Install: pip install datafog=={{version}} + +#DataPrivacy #Python #OpenSource #PII #DataProtection +``` + +## Discord Template + +```` +šŸš€ **DataFog {{version}} is live!** + +**This week's highlights:** +{{highlights}} + +**Performance:** {{speed_stat}} +**Package size:** {{size_stat}} + +**Install now:** +```bash +pip install datafog=={{version}} +```` + +Drop your feedback in #general! šŸ™ + +``` + +## GitHub Release Description Template +``` + +## What's New in {{version}} + +{{changelog_content}} + +## šŸš€ Quick Start + +### Lightweight Core (Recommended) + +```bash +pip install datafog=={{version}} +``` + +### Full Features + +```bash +pip install datafog[all]=={{version}} +``` + +## šŸ“Š Performance Metrics + +- **Processing Speed:** 190x faster than spaCy +- **Package Size:** ~2MB (core), ~8MB (full) +- **Install Time:** <15 seconds +- **Python Support:** 3.10, 3.11, 3.12 + +## šŸ”— Resources + +- [Documentation](https://docs.datafog.ai) +- [Quick Start Guide](https://github.com/datafog/datafog-python#quick-start) +- [Discord Community](https://discord.gg/bzDth394R4) + +## šŸ™ Community + +Thanks to all contributors and users providing feedback! + +ā­ Star us on GitHub if DataFog is helpful for your projects. +šŸ› Report issues or request features in our [issue tracker](https://github.com/datafog/datafog-python/issues). + +--- + +**Weekly releases every Friday** ā€¢ Next release: {{next_friday}} + +``` + +```