greenmining 0.1.4__py3-none-any.whl

greenmining/utils.py

@@ -0,0 +1,320 @@
+"""Utility functions for green microservices mining CLI."""
+
+import json
+import time
+from datetime import datetime
+from functools import wraps
+from pathlib import Path
+from typing import Any, Callable, Optional
+
+import pandas as pd
+from colorama import Fore, Style, init
+
+# Initialize colorama
+init(autoreset=True)
+
+
+def format_timestamp(dt: Optional[datetime] = None) -> str:
+    """Format timestamp in ISO 8601 format.
+
+    Args:
+        dt: Datetime object, defaults to now
+
+    Returns:
+        ISO formatted timestamp string
+    """
+    if dt is None:
+        dt = datetime.utcnow()
+    return dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def load_json_file(path: Path) -> dict[str, Any]:
+    """Load JSON data from file.
+
+    Args:
+        path: Path to JSON file
+
+    Returns:
+        Parsed JSON data
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+        json.JSONDecodeError: If file is not valid JSON
+    """
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    with open(path, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_json_file(data: dict[str, Any], path: Path, indent: int = 2) -> None:
+    """Save data to JSON file.
+
+    Args:
+        data: Data to save
+        path: Output file path
+        indent: JSON indentation level
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=indent, ensure_ascii=False)
+
+
+def load_csv_file(path: Path) -> pd.DataFrame:
+    """Load CSV file as pandas DataFrame.
+
+    Args:
+        path: Path to CSV file
+
+    Returns:
+        DataFrame with CSV data
+
+    Raises:
+        FileNotFoundError: If file doesn't exist
+    """
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    return pd.read_csv(path)
+
+
+def save_csv_file(df: pd.DataFrame, path: Path) -> None:
+    """Save DataFrame to CSV file.
+
+    Args:
+        df: DataFrame to save
+        path: Output file path
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    df.to_csv(path, index=False, encoding="utf-8")
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate number of tokens in text.
+
+    Uses rough approximation: 1 token ≈ 4 characters
+
+    Args:
+        text: Input text
+
+    Returns:
+        Estimated token count
+    """
+    return len(text) // 4
+
+
+def estimate_cost(tokens: int, model: str = "claude-sonnet-4-20250514") -> float:
+    """Estimate API cost based on token usage.
+
+    Args:
+        tokens: Number of tokens
+        model: Model name
+
+    Returns:
+        Estimated cost in USD
+    """
+    # Claude Sonnet 4 pricing (as of Dec 2024)
+    # Input: $3 per million tokens
+    # Output: $15 per million tokens
+    # Average estimate: assume 50% input, 50% output
+
+    if "sonnet" in model.lower():
+        input_cost = 3.0 / 1_000_000  # per token
+        output_cost = 15.0 / 1_000_000  # per token
+        avg_cost = (input_cost + output_cost) / 2
+        return tokens * avg_cost
+
+    return 0.0
+
+
+def retry_on_exception(
+    max_retries: int = 3,
+    delay: float = 2.0,
+    exponential_backoff: bool = True,
+    exceptions: tuple = (Exception,),
+) -> Callable:
+    """Decorator to retry function on exception.
+
+    Args:
+        max_retries: Maximum number of retry attempts
+        delay: Initial delay between retries in seconds
+        exponential_backoff: Use exponential backoff for delays
+        exceptions: Tuple of exception types to catch
+
+    Returns:
+        Decorated function
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            current_delay = delay
+
+            for attempt in range(max_retries + 1):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    if attempt == max_retries:
+                        raise
+
+                    colored_print(f"Attempt {attempt + 1}/{max_retries + 1} failed: {e}", "yellow")
+                    colored_print(f"Retrying in {current_delay:.1f} seconds...", "yellow")
+
+                    time.sleep(current_delay)
+
+                    if exponential_backoff:
+                        current_delay *= 2
+
+            return None
+
+        return wrapper
+
+    return decorator
+
+
+def colored_print(text: str, color: str = "white") -> None:
+    """Print colored text to console.
+
+    Args:
+        text: Text to print
+        color: Color name (red, green, yellow, blue, magenta, cyan, white)
+    """
+    color_map = {
+        "red": Fore.RED,
+        "green": Fore.GREEN,
+        "yellow": Fore.YELLOW,
+        "blue": Fore.BLUE,
+        "magenta": Fore.MAGENTA,
+        "cyan": Fore.CYAN,
+        "white": Fore.WHITE,
+    }
+
+    color_code = color_map.get(color.lower(), Fore.WHITE)
+    print(f"{color_code}{text}{Style.RESET_ALL}")
+
+
+def handle_github_rate_limit(response) -> None:
+    """Handle GitHub API rate limiting.
+
+    Args:
+        response: GitHub API response object
+
+    Raises:
+        Exception: If rate limit is exceeded
+    """
+    if hasattr(response, "status") and response.status == 403:
+        colored_print("GitHub API rate limit exceeded!", "red")
+        colored_print("Please wait or use an authenticated token.", "yellow")
+        raise Exception("GitHub API rate limit exceeded")
+
+
+def format_number(num: int) -> str:
+    """Format large numbers with thousand separators.
+
+    Args:
+        num: Number to format
+
+    Returns:
+        Formatted string
+    """
+    return f"{num:,}"
+
+
+def format_percentage(value: float, decimals: int = 1) -> str:
+    """Format percentage value.
+
+    Args:
+        value: Percentage value (0-100)
+        decimals: Number of decimal places
+
+    Returns:
+        Formatted percentage string
+    """
+    return f"{value:.{decimals}f}%"
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in human-readable format.
+
+    Args:
+        seconds: Duration in seconds
+
+    Returns:
+        Formatted duration string (e.g., "2h 15m")
+    """
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = int(seconds / 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s"
+    else:
+        hours = int(seconds / 3600)
+        minutes = int((seconds % 3600) / 60)
+        return f"{hours}h {minutes}m"
+
+
+def truncate_text(text: str, max_length: int = 100) -> str:
+    """Truncate text to maximum length.
+
+    Args:
+        text: Input text
+        max_length: Maximum length
+
+    Returns:
+        Truncated text with ellipsis if needed
+    """
+    if len(text) <= max_length:
+        return text
+    return text[: max_length - 3] + "..."
+
+
+def create_checkpoint(checkpoint_file: Path, data: dict[str, Any]) -> None:
+    """Create checkpoint file for resuming operations.
+
+    Args:
+        checkpoint_file: Path to checkpoint file
+        data: Checkpoint data
+    """
+    save_json_file(data, checkpoint_file)
+    colored_print(f"Checkpoint saved: {checkpoint_file}", "green")
+
+
+def load_checkpoint(checkpoint_file: Path) -> Optional[dict[str, Any]]:
+    """Load checkpoint data if exists.
+
+    Args:
+        checkpoint_file: Path to checkpoint file
+
+    Returns:
+        Checkpoint data or None if doesn't exist
+    """
+    if checkpoint_file.exists():
+        try:
+            return load_json_file(checkpoint_file)
+        except Exception as e:
+            colored_print(f"Failed to load checkpoint: {e}", "yellow")
+    return None
+
+
+def print_banner(title: str) -> None:
+    """Print formatted banner.
+
+    Args:
+        title: Banner title
+    """
+    colored_print("\n" + "=" * 60, "cyan")
+    colored_print(f"🔍 {title}", "cyan")
+    colored_print("=" * 60 + "\n", "cyan")
+
+
+def print_section(title: str) -> None:
+    """Print section header.
+
+    Args:
+        title: Section title
+    """
+    colored_print(f"\n📌 {title}", "blue")
+    colored_print("-" * 60, "blue")

greenmining-0.1.4.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.4
+Name: greenmining
+Version: 0.1.4
+Summary: Green Software Foundation (GSF) patterns mining tool for microservices repositories
+Author-email: Your Name <your.email@example.com>
+Maintainer-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/greenmining
+Project-URL: Documentation, https://github.com/yourusername/greenmining#readme
+Project-URL: Repository, https://github.com/yourusername/greenmining
+Project-URL: Issues, https://github.com/yourusername/greenmining/issues
+Project-URL: Changelog, https://github.com/yourusername/greenmining/blob/main/CHANGELOG.md
+Keywords: green-software,gsf,sustainability,carbon-footprint,microservices,mining,repository-analysis,energy-efficiency,github-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyGithub>=2.1.1
+Requires-Dist: PyDriller>=2.5
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: click>=8.1.7
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: matplotlib>=3.8.0
+Requires-Dist: plotly>=5.18.0
+Requires-Dist: python-dotenv>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: black>=23.12.0; extra == "dev"
+Requires-Dist: ruff>=0.1.9; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: build>=1.0.3; extra == "dev"
+Requires-Dist: twine>=4.0.2; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.2.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=2.0.0; extra == "docs"
+Requires-Dist: myst-parser>=2.0.0; extra == "docs"
+Dynamic: license-file
+
+# greenmining
+
+Green mining for microservices repositories.
+
+[![PyPI](https://img.shields.io/pypi/v/greenmining)](https://pypi.org/project/greenmining/)
+[![Python](https://img.shields.io/pypi/pyversions/greenmining)](https://pypi.org/project/greenmining/)
+[![License](https://img.shields.io/github/license/adam-bouafia/greenmining)](LICENSE)
+
+## Overview
+
+`greenmining` is a Python library and CLI tool for analyzing GitHub repositories to identify green software engineering practices. It detects 76 official Green Software Foundation patterns across cloud, web, AI, database, networking, and general categories.
+
+## Features
+
+- 🔍 **76 GSF Patterns**: Detect official Green Software Foundation patterns
+- 📊 **Repository Mining**: Analyze 100+ microservices repositories from GitHub
+- 📈 **Green Awareness Detection**: Identify sustainability-focused commits
+- 📄 **Comprehensive Reports**: Generate analysis reports in multiple formats
+- 🐳 **Docker Support**: Run in containers for consistent environments
+- ⚡ **Fast Analysis**: Parallel processing and checkpoint system
+
+## Installation
+
+### Via pip
+
+```bash
+pip install greenmining
+```
+
+### From source
+
+```bash
+git clone https://github.com/adam-bouafia/greenmining.git
+cd greenmining
+pip install -e .
+```
+
+### With Docker
+
+```bash
+docker pull adambouafia/greenmining:latest
+```
+
+## Quick Start
+
+### CLI Usage
+
+```bash
+# Set your GitHub token
+export GITHUB_TOKEN="your_github_token"
+
+# Run full analysis pipeline
+greenmining pipeline --max-repos 100
+
+# Fetch repositories
+greenmining fetch --max-repos 100 --min-stars 100
+
+# Extract commits
+greenmining extract --max-commits 50
+
+# Analyze for green patterns
+greenmining analyze
+
+# Generate report
+greenmining report
+```
+
+### Python API
+
+#### Basic Pattern Detection
+
+```python
+from greenmining import GSF_PATTERNS, is_green_aware, get_pattern_by_keywords
+
+# Check available patterns
+print(f"Total GSF patterns: {len(GSF_PATTERNS)}")  # 76
+
+# Detect green awareness in commit messages
+commit_msg = "Optimize Redis caching to reduce energy consumption"
+if is_green_aware(commit_msg):
+    patterns = get_pattern_by_keywords(commit_msg)
+    print(f"Matched patterns: {patterns}")
+    # Output: ['Cache Static Data', 'Use Efficient Cache Strategies']
+```
+
+#### Analyze Repository Commits
+
+```python
+from greenmining.services.github_fetcher import GitHubFetcher
+from greenmining.services.commit_extractor import CommitExtractor
+from greenmining.services.data_analyzer import DataAnalyzer
+from greenmining.config import Config
+
+# Initialize services
+config = Config()
+fetcher = GitHubFetcher(config)
+extractor = CommitExtractor(config)
+analyzer = DataAnalyzer(config)
+
+# Fetch repositories
+repos = fetcher.fetch_repositories(max_repos=10, min_stars=100)
+
+# Extract commits from first repo
+commits = extractor.extract_commits(repos[0], max_commits=50)
+
+# Analyze commits for green patterns
+results = []
+for commit in commits:
+    result = analyzer.analyze_commit(commit)
+    if result['green_aware']:
+        results.append(result)
+        print(f"Green commit found: {commit.message[:50]}...")
+        print(f"  Patterns: {result['known_pattern']}")
+```
+
+#### Access GSF Patterns Data
+
+```python
+from greenmining import GSF_PATTERNS
+
+# Get all cloud patterns
+cloud_patterns = {
+    pid: pattern for pid, pattern in GSF_PATTERNS.items()
+    if pattern['category'] == 'cloud'
+}
+print(f"Cloud patterns: {len(cloud_patterns)}")
+
+# Get pattern details
+cache_pattern = GSF_PATTERNS['gsf_001']
+print(f"Pattern: {cache_pattern['name']}")
+print(f"Category: {cache_pattern['category']}")
+print(f"Keywords: {cache_pattern['keywords']}")
+print(f"Impact: {cache_pattern['sci_impact']}")
+```
+
+#### Generate Custom Reports
+
+```python
+from greenmining.services.data_aggregator import DataAggregator
+from greenmining.config import Config
+
+config = Config()
+aggregator = DataAggregator(config)
+
+# Load analysis results
+results = aggregator.load_analysis_results()
+
+# Generate statistics
+stats = aggregator.calculate_statistics(results)
+print(f"Total commits analyzed: {stats['total_commits']}")
+print(f"Green-aware commits: {stats['green_aware_count']}")
+print(f"Top patterns: {stats['top_patterns'][:5]}")
+
+# Export to CSV
+aggregator.export_to_csv(results, "output.csv")
+```
+
+#### Batch Analysis
+
+```python
+from greenmining.controllers.repository_controller import RepositoryController
+from greenmining.config import Config
+
+config = Config()
+controller = RepositoryController(config)
+
+# Run full pipeline programmatically
+controller.fetch_repositories(max_repos=50)
+controller.extract_commits(max_commits=100)
+controller.analyze_commits()
+controller.aggregate_results()
+controller.generate_report()
+
+print("Analysis complete! Check data/ directory for results.")
+```
+
+### Docker Usage
+
+```bash
+# Run analysis pipeline
+docker run -v $(pwd)/data:/app/data \
+           adambouafia/greenmining:latest --help
+
+# With custom configuration
+docker run -v $(pwd)/.env:/app/.env:ro \
+           -v $(pwd)/data:/app/data \
+           adambouafia/greenmining:latest pipeline --max-repos 50
+
+# Interactive shell
+docker run -it adambouafia/greenmining:latest /bin/bash
+```
+
+## Configuration
+
+Create a `.env` file or set environment variables:
+
+```bash
+GITHUB_TOKEN=your_github_personal_access_token
+MAX_REPOS=100
+COMMITS_PER_REPO=50
+OUTPUT_DIR=./data
+```
+
+## GSF Pattern Categories
+
+- **Cloud** (40 patterns): Autoscaling, serverless, right-sizing, region selection
+- **Web** (15 patterns): CDN, caching, lazy loading, compression
+- **AI/ML** (8 patterns): Model optimization, pruning, quantization
+- **Database** (6 patterns): Indexing, query optimization, connection pooling
+- **Networking** (4 patterns): Protocol optimization, connection reuse
+- **General** (3 patterns): Code efficiency, resource management
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `fetch` | Fetch microservices repositories from GitHub |
+| `extract` | Extract commit history from repositories |
+| `analyze` | Analyze commits for green patterns |
+| `aggregate` | Aggregate analysis results |
+| `report` | Generate comprehensive report |
+| `pipeline` | Run complete analysis pipeline |
+| `status` | Show current analysis status |
+
+## Output Files
+
+All outputs are saved to the `data/` directory:
+
+- `repositories.json` - Repository metadata
+- `commits.json` - Extracted commit data
+- `analysis_results.json` - Pattern analysis results
+- `aggregated_statistics.json` - Summary statistics
+- `green_analysis_results.csv` - CSV export for spreadsheets
+- `green_microservices_analysis.md` - Final report
+
+## Development
+
+```bash
+# Clone repository
+git clone https://github.com/adam-bouafia/greenmining.git
+cd greenmining
+
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest tests/
+
+# Run with coverage
+pytest --cov=greenmining tests/
+
+# Format code
+black greenmining/ tests/
+ruff check greenmining/ tests/
+```
+
+## Requirements
+
+- Python 3.9+
+- PyGithub >= 2.1.1
+- PyDriller >= 2.5
+- pandas >= 2.2.0
+- click >= 8.1.7
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Links
+
+- **GitHub**: https://github.com/adam-bouafia/greenmining
+- **PyPI**: https://pypi.org/project/greenmining/
+- **Docker Hub**: https://hub.docker.com/r/adambouafia/greenmining
+- **Documentation**: https://github.com/adam-bouafia/greenmining#readme
+
+

greenmining-0.1.4.dist-info/RECORD

@@ -0,0 +1,29 @@
+greenmining/__init__.py,sha256=ITaqGeXxagpd_NwAF68-WFLmWVP4iNeP6t4hici3ktA,395
+greenmining/__main__.py,sha256=1RwcSXcwdza6xJX5fRT8-HhZjlnKbkmGY_uxTm-NYZ4,138
+greenmining/__version__.py,sha256=YXwH4HqFWIba-TCs8Y_eGeQcHAjoSopf1uNTJSxiheI,66
+greenmining/cli.py,sha256=11DEE9bwKDIzj8CbR4-B8re_1cmywPo1CyLGWVGzF9U,13254
+greenmining/config.py,sha256=jTWEIHIwRiQmdoGV5iCILT_nPTka6ZX1DL5ltTIzWJ0,4004
+greenmining/gsf_patterns.py,sha256=jwQ7WZLVLQ-9bqR4W_VYc3HZBC_c1sm0ECDazsfxv-I,29903
+greenmining/main.py,sha256=h8J9OcwyGpVJ-gjSFUS2SZExQQlHV0eDMMjAoI_sgAo,952
+greenmining/utils.py,sha256=-pL8yznf1jSazBMk1ugjPQbtFOQI1E9wRI1NJbHl2xs,7941
+greenmining/controllers/__init__.py,sha256=y-W1Xnnhm4JnrY2QEo5osK8jQs7hpxXovVbHlE334F0,279
+greenmining/controllers/repository_controller.py,sha256=q2JO5LtmpWRbNzVrE9lFBhHU0kcDSlkG3TVIB6mYqGY,4278
+greenmining/models/__init__.py,sha256=K8udzQW2V5LqPowIm5aCiK07LxJZxCt_oW3gz5Qi-mc,397
+greenmining/models/aggregated_stats.py,sha256=SysZD7ZeyvOG4Qsq9B_JdMjI5NpKCNKC63sJ6-s2k2M,984
+greenmining/models/analysis_result.py,sha256=-6hwmickqncRXDGWM3aXBEaOGlddM5G6hnmRTyHFcMs,1525
+greenmining/models/commit.py,sha256=9-PbZmHSyorD1ed13rFkrT9u5XOG7SBT5Nowlr82-PE,2399
+greenmining/models/repository.py,sha256=lpe9Pte6KPCcRvx0aOH16v2PiH3NwjPeQRJYxriKnns,2834
+greenmining/presenters/__init__.py,sha256=-ukAvhNuTvy1Xpknps0faDZ78HKdPHPySzFpQHABzKM,203
+greenmining/presenters/console_presenter.py,sha256=jK_8agdEz-_2mqoyMNht-mNA9hXWe9EA8VlAUT_XFxA,5299
+greenmining/services/__init__.py,sha256=7CJDjHMTrY0bBoqzx22AUzIwEvby0FbAUUKYbjSlNPQ,460
+greenmining/services/commit_extractor.py,sha256=IxON_s6p9Rp4JJN8Q8T0bMLxBtatN4W7bCtk72snBSI,9900
+greenmining/services/data_aggregator.py,sha256=8yb70_lwT85Cn8jVDLUrEZXcGr44UKy8UEFTHbAebZg,16250
+greenmining/services/data_analyzer.py,sha256=ejvfKoG19D1U-b_RBne3e66h2yF4k05gyv3BLnZB9_k,11856
+greenmining/services/github_fetcher.py,sha256=9aHSbZoA8BWL1Cp0cCv2NltXf0Jr7W_mO5d_-7TuOvY,9294
+greenmining/services/reports.py,sha256=cE7XvB2ihD5KwrO4W1Uj_I1h5pELBPF85MjgGFzkgOQ,21829
+greenmining-0.1.4.dist-info/licenses/LICENSE,sha256=M7ma3JHGeiIZIs3ea0HTcFl_wLFPX2NZElUliYs4bCA,1083
+greenmining-0.1.4.dist-info/METADATA,sha256=I8cXBLwYVRogUrDNUQtoidiL3zgip5PqwvszhvmnOLA,9892
+greenmining-0.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+greenmining-0.1.4.dist-info/entry_points.txt,sha256=oHvTWMzNFGf2W3CFEKVVPsG4exeMv0MaQu9YsUoQ9lw,53
+greenmining-0.1.4.dist-info/top_level.txt,sha256=nreXgXxZIWI-42yQknQ0HXtUrFnzZ8N1ra4Mdy2KcsI,12
+greenmining-0.1.4.dist-info/RECORD,,

greenmining-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

greenmining-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+greenmining = greenmining.cli:main