stylometric-ai-detector 0.2.1__tar.gz

stylometric_ai_detector-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dinis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stylometric_ai_detector-0.2.1/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: stylometric-ai-detector
+Version: 0.2.1
+Summary: AI vs Human text detection using stylometric features and Random Forest
+Author: Dinis
+License: MIT License
+        
+        Copyright (c) 2026 Dinis
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/dinis-a/test-stylometry
+Project-URL: Repository, https://github.com/dinis-a/test-stylometry
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: joblib>=1.0
+Requires-Dist: huggingface_hub>=0.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Dynamic: license-file
+
+# stylometric-ai-detector
+
+AI vs Human text detection using stylometric features and a Random Forest classifier.
+
+## Overview
+
+This library provides two functions:
+- **`extract_stylometric_features(text)`** — Extract 8 stylometric features from any text.
+- **`predict(text)`** — Classify text as AI-generated or human-written, with a confidence score.
+
+The model is a Random Forest classifier achieving **96% accuracy**, trained on the [AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset. On first use, the model is automatically downloaded from Hugging Face and cached locally.
+
+## Installation
+
+```bash
+pip install stylometric-ai-detector
+```
+
+For the latest dev version from Test PyPI:
+
+```bash
+pip install -i https://test.pypi.org/simple/ stylometric-ai-detector
+```
+
+## Quick Start
+
+```python
+from stylometric_ai_detector import extract_stylometric_features, predict
+
+# Extract stylometric features
+features = extract_stylometric_features("The quick brown fox jumps over the lazy dog.")
+print(features)
+# {
+#     'char_count': 44,
+#     'word_count': 9,
+#     'avg_word_len': 3.777...,
+#     'punct_count': 1,
+#     'sentence_count': 1,
+#     'avg_sentence_len': 9.0,
+#     'upper_case_count': 0,
+#     'title_case_count': 1,
+# }
+
+# Predict AI vs Human (model auto-downloaded from Hugging Face on first call)
+result = predict(text="Artificial intelligence is transforming our world.")
+print(result)
+# {'label': 'AI', 'probability': 0.87}
+
+# Or pass pre-computed features
+result = predict(features=features)
+print(result)
+# {'label': 'Human', 'probability': 0.92}
+```
+
+## Stylometric Features
+
+| Feature            | Description                                   |
+|--------------------|-----------------------------------------------|
+| `char_count`       | Total number of characters                    |
+| `word_count`       | Total number of words                         |
+| `avg_word_len`     | Average word length                           |
+| `punct_count`      | Number of punctuation characters              |
+| `sentence_count`   | Number of sentences                           |
+| `avg_sentence_len` | Average sentence length (in words)            |
+| `upper_case_count` | Number of fully uppercase alphabetic words     |
+| `title_case_count` | Number of title-case words                    |
+
+## Model
+
+The trained Random Forest model is hosted on Hugging Face at [`dinisds/stylometric-ai-detector`](https://huggingface.co/dinisds/stylometric-ai-detector). It is downloaded and cached to `~/.cache/stylometric-ai-detector/` on first use — no extra setup needed.
+
+## Dataset
+
+Trained on [Shanegerami's AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset from Kaggle. The dataset contains ~487k text samples labeled as human-written (0) or AI-generated (1).
+
+## License
+
+MIT

stylometric_ai_detector-0.2.1/README.md

@@ -0,0 +1,78 @@
+# stylometric-ai-detector
+
+AI vs Human text detection using stylometric features and a Random Forest classifier.
+
+## Overview
+
+This library provides two functions:
+- **`extract_stylometric_features(text)`** — Extract 8 stylometric features from any text.
+- **`predict(text)`** — Classify text as AI-generated or human-written, with a confidence score.
+
+The model is a Random Forest classifier achieving **96% accuracy**, trained on the [AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset. On first use, the model is automatically downloaded from Hugging Face and cached locally.
+
+## Installation
+
+```bash
+pip install stylometric-ai-detector
+```
+
+For the latest dev version from Test PyPI:
+
+```bash
+pip install -i https://test.pypi.org/simple/ stylometric-ai-detector
+```
+
+## Quick Start
+
+```python
+from stylometric_ai_detector import extract_stylometric_features, predict
+
+# Extract stylometric features
+features = extract_stylometric_features("The quick brown fox jumps over the lazy dog.")
+print(features)
+# {
+#     'char_count': 44,
+#     'word_count': 9,
+#     'avg_word_len': 3.777...,
+#     'punct_count': 1,
+#     'sentence_count': 1,
+#     'avg_sentence_len': 9.0,
+#     'upper_case_count': 0,
+#     'title_case_count': 1,
+# }
+
+# Predict AI vs Human (model auto-downloaded from Hugging Face on first call)
+result = predict(text="Artificial intelligence is transforming our world.")
+print(result)
+# {'label': 'AI', 'probability': 0.87}
+
+# Or pass pre-computed features
+result = predict(features=features)
+print(result)
+# {'label': 'Human', 'probability': 0.92}
+```
+
+## Stylometric Features
+
+| Feature            | Description                                   |
+|--------------------|-----------------------------------------------|
+| `char_count`       | Total number of characters                    |
+| `word_count`       | Total number of words                         |
+| `avg_word_len`     | Average word length                           |
+| `punct_count`      | Number of punctuation characters              |
+| `sentence_count`   | Number of sentences                           |
+| `avg_sentence_len` | Average sentence length (in words)            |
+| `upper_case_count` | Number of fully uppercase alphabetic words     |
+| `title_case_count` | Number of title-case words                    |
+
+## Model
+
+The trained Random Forest model is hosted on Hugging Face at [`dinisds/stylometric-ai-detector`](https://huggingface.co/dinisds/stylometric-ai-detector). It is downloaded and cached to `~/.cache/stylometric-ai-detector/` on first use — no extra setup needed.
+
+## Dataset
+
+Trained on [Shanegerami's AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset from Kaggle. The dataset contains ~487k text samples labeled as human-written (0) or AI-generated (1).
+
+## License
+
+MIT

stylometric_ai_detector-0.2.1/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "stylometric-ai-detector"
+version = "0.2.1"
+description = "AI vs Human text detection using stylometric features and Random Forest"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Dinis"},
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Text Processing :: Linguistic",
+]
+dependencies = [
+    "scikit-learn>=1.0",
+    "joblib>=1.0",
+    "huggingface_hub>=0.20",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "isort>=5.0",
+    "black>=23.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/dinis-a/test-stylometry"
+Repository = "https://github.com/dinis-a/test-stylometry"
+
+[tool.setuptools.packages.find]
+include = ["stylometric_ai_detector*"]
+
+[tool.isort]
+profile = "black"
+line_length = 100
+
+[tool.black]
+line-length = 100
+target-version = ["py39"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

stylometric_ai_detector-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

stylometric_ai_detector-0.2.1/stylometric_ai_detector/__init__.py

@@ -0,0 +1,15 @@
+"""stylometric-ai-detector: AI vs Human text detection using stylometric features and Random Forest.
+
+Trained on the "AI vs Human Text" dataset from Kaggle:
+https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text
+
+Provides two main functions:
+- extract_stylometric_features(text) -> dict
+- predict(text=None, features=None) -> dict
+"""
+
+from stylometric_ai_detector.features import extract_stylometric_features
+from stylometric_ai_detector.predict import predict
+
+__all__ = ["extract_stylometric_features", "predict"]
+__version__ = "0.2.1"

stylometric_ai_detector-0.2.1/stylometric_ai_detector/features.py

@@ -0,0 +1,63 @@
+"""Stylometric feature extraction for text analysis."""
+
+import re
+import string
+
+
+def extract_stylometric_features(text):
+    """Extract 8 stylometric features from a text string.
+
+    Features extracted:
+        - char_count: Total number of characters
+        - word_count: Total number of words
+        - avg_word_len: Average word length
+        - punct_count: Number of punctuation characters
+        - sentence_count: Number of sentences
+        - avg_sentence_len: Average sentence length in words
+        - upper_case_count: Number of fully uppercase alphabetic words
+        - title_case_count: Number of title-case words
+
+    Args:
+        text: Input text string.
+
+    Returns:
+        dict with keys: char_count, word_count, avg_word_len, punct_count,
+                        sentence_count, avg_sentence_len, upper_case_count,
+                        title_case_count.
+    """
+    if not isinstance(text, str) or not text.strip():
+        return {
+            "char_count": 0,
+            "word_count": 0,
+            "avg_word_len": 0.0,
+            "punct_count": 0,
+            "sentence_count": 0,
+            "avg_sentence_len": 0.0,
+            "upper_case_count": 0,
+            "title_case_count": 0,
+        }
+
+    char_count = len(text)
+    words = text.split()
+    word_count = len(words)
+    avg_word_len = sum(len(w) for w in words) / word_count if word_count > 0 else 0.0
+    punct_count = sum(1 for c in text if c in string.punctuation)
+
+    sentences = re.split(r"[.!?]+", text)
+    sentence_count = len([s for s in sentences if s.strip()])
+    sentence_count = sentence_count if sentence_count > 0 else 1  # avoid division by zero
+    avg_sentence_len = word_count / sentence_count
+
+    upper_case_count = sum(1 for w in words if w.isupper() and w.isalpha())
+    title_case_count = sum(1 for w in words if w.istitle())
+
+    return {
+        "char_count": char_count,
+        "word_count": word_count,
+        "avg_word_len": avg_word_len,
+        "punct_count": punct_count,
+        "sentence_count": sentence_count,
+        "avg_sentence_len": avg_sentence_len,
+        "upper_case_count": upper_case_count,
+        "title_case_count": title_case_count,
+    }

stylometric_ai_detector-0.2.1/stylometric_ai_detector/predict.py

@@ -0,0 +1,122 @@
+"""AI vs Human text prediction using stylometric features and a trained Random Forest model.
+
+The model is hosted on Hugging Face and downloaded/cached on first use.
+"""
+
+import logging
+import os
+import warnings
+
+import joblib
+from huggingface_hub import hf_hub_download
+
+from stylometric_ai_detector.features import extract_stylometric_features
+
+logger = logging.getLogger(__name__)
+
+# Feature order matching the trained model
+_FEATURE_ORDER = [
+    "char_count",
+    "word_count",
+    "avg_word_len",
+    "punct_count",
+    "sentence_count",
+    "avg_sentence_len",
+    "upper_case_count",
+    "title_case_count",
+]
+
+# Hugging Face model repo configuration
+_HF_REPO_ID = os.environ.get("HF_MODEL_REPO", "dinisds/stylometric-ai-detector")
+_HF_FILENAME = "random_forest_stylometric_model.joblib"
+_CACHE_DIR = os.path.join(os.path.expanduser("~"), ".cache", "stylometric-ai-detector")
+
+_model = None
+
+
+def _load_model():
+    """Lazy-load the model, downloading from Hugging Face on first use.
+
+    Lookup order:
+    1. Package data directory (bundled in wheel / local dev)
+    2. User cache directory (~/.cache/stylometric-ai-detector/)
+    3. Download from Hugging Face
+    """
+    global _model
+    if _model is None:
+        os.makedirs(_CACHE_DIR, exist_ok=True)
+
+        local_path = None
+
+        # 1. Check package data directory (bundled model or local dev)
+        pkg_path = os.path.join(os.path.dirname(__file__), "data", _HF_FILENAME)
+        if os.path.exists(pkg_path):
+            local_path = pkg_path
+
+        # 2. Check user cache
+        if local_path is None:
+            cache_path = os.path.join(_CACHE_DIR, _HF_FILENAME)
+            if os.path.exists(cache_path):
+                local_path = cache_path
+
+        # 3. Download from Hugging Face
+        if local_path is None:
+            logger.info("Downloading model from Hugging Face: %s", _HF_REPO_ID)
+            local_path = hf_hub_download(
+                repo_id=_HF_REPO_ID,
+                filename=_HF_FILENAME,
+                cache_dir=_CACHE_DIR,
+            )
+
+        _model = joblib.load(local_path)
+    return _model
+
+
+def _features_to_array(features_dict):
+    """Convert a feature dict to the ordered array expected by the model."""
+    return [[features_dict[k] for k in _FEATURE_ORDER]]
+
+
+def predict(text=None, features=None):
+    """Predict whether a text was written by AI or a human.
+
+    Provide either `text` (raw string) or `features` (pre-computed feature dict).
+    If both are provided, `text` takes precedence and features are extracted from it.
+
+    The model is downloaded from Hugging Face on first use and cached locally.
+
+    Args:
+        text: Raw text string to classify.
+        features: Pre-computed stylometric feature dict (from extract_stylometric_features).
+
+    Returns:
+        dict with:
+            - label: "AI" or "Human"
+            - probability: Confidence score for the predicted class (float between 0 and 1).
+
+    Raises:
+        ValueError: If neither text nor features is provided.
+        OSError: If the model cannot be downloaded from Hugging Face.
+    """
+    if text is not None:
+        features = extract_stylometric_features(text)
+    elif features is None:
+        raise ValueError("Either 'text' or 'features' must be provided.")
+
+    model = _load_model()
+    X = _features_to_array(features)
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            "ignore",
+            message="X does not have valid feature names",
+            category=UserWarning,
+        )
+        prediction = model.predict(X)[0]
+        probabilities = model.predict_proba(X)[0]
+
+    label = "AI" if prediction == 1.0 else "Human"
+
+    return {
+        "label": label,
+        "probability": float(max(probabilities)),
+    }

stylometric_ai_detector-0.2.1/stylometric_ai_detector.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: stylometric-ai-detector
+Version: 0.2.1
+Summary: AI vs Human text detection using stylometric features and Random Forest
+Author: Dinis
+License: MIT License
+        
+        Copyright (c) 2026 Dinis
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/dinis-a/test-stylometry
+Project-URL: Repository, https://github.com/dinis-a/test-stylometry
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: joblib>=1.0
+Requires-Dist: huggingface_hub>=0.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: isort>=5.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Dynamic: license-file
+
+# stylometric-ai-detector
+
+AI vs Human text detection using stylometric features and a Random Forest classifier.
+
+## Overview
+
+This library provides two functions:
+- **`extract_stylometric_features(text)`** — Extract 8 stylometric features from any text.
+- **`predict(text)`** — Classify text as AI-generated or human-written, with a confidence score.
+
+The model is a Random Forest classifier achieving **96% accuracy**, trained on the [AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset. On first use, the model is automatically downloaded from Hugging Face and cached locally.
+
+## Installation
+
+```bash
+pip install stylometric-ai-detector
+```
+
+For the latest dev version from Test PyPI:
+
+```bash
+pip install -i https://test.pypi.org/simple/ stylometric-ai-detector
+```
+
+## Quick Start
+
+```python
+from stylometric_ai_detector import extract_stylometric_features, predict
+
+# Extract stylometric features
+features = extract_stylometric_features("The quick brown fox jumps over the lazy dog.")
+print(features)
+# {
+#     'char_count': 44,
+#     'word_count': 9,
+#     'avg_word_len': 3.777...,
+#     'punct_count': 1,
+#     'sentence_count': 1,
+#     'avg_sentence_len': 9.0,
+#     'upper_case_count': 0,
+#     'title_case_count': 1,
+# }
+
+# Predict AI vs Human (model auto-downloaded from Hugging Face on first call)
+result = predict(text="Artificial intelligence is transforming our world.")
+print(result)
+# {'label': 'AI', 'probability': 0.87}
+
+# Or pass pre-computed features
+result = predict(features=features)
+print(result)
+# {'label': 'Human', 'probability': 0.92}
+```
+
+## Stylometric Features
+
+| Feature            | Description                                   |
+|--------------------|-----------------------------------------------|
+| `char_count`       | Total number of characters                    |
+| `word_count`       | Total number of words                         |
+| `avg_word_len`     | Average word length                           |
+| `punct_count`      | Number of punctuation characters              |
+| `sentence_count`   | Number of sentences                           |
+| `avg_sentence_len` | Average sentence length (in words)            |
+| `upper_case_count` | Number of fully uppercase alphabetic words     |
+| `title_case_count` | Number of title-case words                    |
+
+## Model
+
+The trained Random Forest model is hosted on Hugging Face at [`dinisds/stylometric-ai-detector`](https://huggingface.co/dinisds/stylometric-ai-detector). It is downloaded and cached to `~/.cache/stylometric-ai-detector/` on first use — no extra setup needed.
+
+## Dataset
+
+Trained on [Shanegerami's AI vs Human Text](https://www.kaggle.com/datasets/shanegerami/ai-vs-human-text) dataset from Kaggle. The dataset contains ~487k text samples labeled as human-written (0) or AI-generated (1).
+
+## License
+
+MIT

stylometric_ai_detector-0.2.1/stylometric_ai_detector.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+stylometric_ai_detector/__init__.py
+stylometric_ai_detector/features.py
+stylometric_ai_detector/predict.py
+stylometric_ai_detector.egg-info/PKG-INFO
+stylometric_ai_detector.egg-info/SOURCES.txt
+stylometric_ai_detector.egg-info/dependency_links.txt
+stylometric_ai_detector.egg-info/requires.txt
+stylometric_ai_detector.egg-info/top_level.txt
+tests/test_features.py
+tests/test_predict.py

stylometric_ai_detector-0.2.1/stylometric_ai_detector.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

stylometric_ai_detector-0.2.1/stylometric_ai_detector.egg-info/requires.txt

@@ -0,0 +1,8 @@
+scikit-learn>=1.0
+joblib>=1.0
+huggingface_hub>=0.20
+
+[dev]
+pytest>=7.0
+isort>=5.0
+black>=23.0

stylometric_ai_detector-0.2.1/stylometric_ai_detector.egg-info/top_level.txt

@@ -0,0 +1 @@
+stylometric_ai_detector

stylometric_ai_detector-0.2.1/tests/test_features.py

@@ -0,0 +1,68 @@
+"""Tests for stylometric feature extraction."""
+
+from stylometric_ai_detector import extract_stylometric_features
+
+
+def test_empty_string():
+    """Empty or whitespace-only strings should return all zeros."""
+    result = extract_stylometric_features("")
+    assert result["char_count"] == 0
+    assert result["word_count"] == 0
+    assert result["avg_word_len"] == 0.0
+
+
+def test_non_string_input():
+    """Non-string input should return all zeros."""
+    result = extract_stylometric_features(None)
+    assert result["char_count"] == 0
+    assert result["word_count"] == 0
+
+
+def test_simple_sentence():
+    """Basic feature extraction on a simple sentence."""
+    text = "Hello world. This is a test."
+    result = extract_stylometric_features(text)
+
+    assert result["char_count"] == len(text)
+    # "Hello", "world.", "This", "is", "a", "test."
+    assert result["word_count"] == 6
+    assert result["sentence_count"] == 2
+    # Punctuation: '.' (after world) and '.' (after test) = 2
+    assert result["punct_count"] == 2
+    # No fully uppercase words
+    assert result["upper_case_count"] == 0
+    # "Hello" and "This" are title-case
+    assert result["title_case_count"] == 2
+
+
+def test_all_feature_keys():
+    """Verify all 8 expected feature keys are present."""
+    result = extract_stylometric_features("Some sample text.")
+    expected_keys = {
+        "char_count",
+        "word_count",
+        "avg_word_len",
+        "punct_count",
+        "sentence_count",
+        "avg_sentence_len",
+        "upper_case_count",
+        "title_case_count",
+    }
+    assert set(result.keys()) == expected_keys
+
+
+def test_longer_text():
+    """Feature extraction on a multi-sentence paragraph."""
+    text = (
+        "Artificial intelligence is transforming the world. "
+        "Many people are excited about the possibilities. "
+        "However, some are concerned about the risks."
+    )
+    result = extract_stylometric_features(text)
+
+    assert result["char_count"] > 0
+    assert result["word_count"] > 10
+    assert result["sentence_count"] == 3
+    assert result["avg_word_len"] > 0
+    assert result["avg_sentence_len"] > 0
+    assert isinstance(result["avg_word_len"], float)

stylometric_ai_detector-0.2.1/tests/test_predict.py

@@ -0,0 +1,81 @@
+"""Tests for the predict function."""
+
+import os
+
+import pytest
+
+# Skip predict tests if model is not cached locally (neither in package nor HF cache)
+_PKG_DIR = os.path.join(os.path.dirname(__file__), "..", "stylometric_ai_detector", "data")
+_CACHE_DIR = os.path.join(os.path.expanduser("~"), ".cache", "stylometric-ai-detector")
+_MODEL_FILENAME = "random_forest_stylometric_model.joblib"
+_MODEL_AVAILABLE = os.path.exists(os.path.join(_PKG_DIR, _MODEL_FILENAME)) or os.path.exists(
+    os.path.join(_CACHE_DIR, _MODEL_FILENAME)
+)
+
+pytestmark = pytest.mark.skipif(
+    not _MODEL_AVAILABLE,
+    reason="Model not cached locally — run predict() once to download from Hugging Face",
+)
+
+
+def test_predict_with_text():
+    """Prediction should work with raw text input."""
+    from stylometric_ai_detector import predict
+
+    result = predict(text="This is a sample sentence for testing purposes.")
+    assert "label" in result
+    assert "probability" in result
+    assert result["label"] in ("AI", "Human")
+    assert 0.0 <= result["probability"] <= 1.0
+
+
+def test_predict_with_features():
+    """Prediction should work with pre-computed feature dict."""
+    from stylometric_ai_detector import extract_stylometric_features, predict
+
+    features = extract_stylometric_features(
+        "The quick brown fox jumps over the lazy dog. It was a sunny day."
+    )
+    result = predict(features=features)
+    assert "label" in result
+    assert "probability" in result
+    assert result["label"] in ("AI", "Human")
+    assert 0.0 <= result["probability"] <= 1.0
+
+
+def test_predict_text_takes_precedence():
+    """When both text and features are given, text should be used."""
+    from stylometric_ai_detector import predict
+
+    result = predict(
+        text="Hello world.",
+        features={
+            "char_count": 999,
+            "word_count": 999,
+            "avg_word_len": 99.0,
+            "punct_count": 99,
+            "sentence_count": 99,
+            "avg_sentence_len": 99.0,
+            "upper_case_count": 99,
+            "title_case_count": 99,
+        },
+    )
+    assert result["label"] in ("AI", "Human")
+
+
+def test_predict_no_input_raises():
+    """Calling predict with no arguments should raise ValueError."""
+    from stylometric_ai_detector import predict
+
+    with pytest.raises(ValueError, match="Either 'text' or 'features' must be provided"):
+        predict()
+
+
+def test_predict_consistency():
+    """Same input should produce the same output."""
+    from stylometric_ai_detector import predict
+
+    text = "The theory of relativity explains the relationship between space and time."
+    result1 = predict(text=text)
+    result2 = predict(text=text)
+    assert result1 == result2