ibrahimpy 0.1.0__tar.gz

ibrahimpy-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include requirements.txt
+include pyproject.toml
+recursive-include ibrahim *.py
+recursive-exclude * __pycache__
+recursive-exclude * *.pyc

ibrahimpy-0.1.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: ibrahimpy
+Version: 0.1.0
+Summary: Intelligent Benchmark Relational Analysis for Heuristic Index Modeling
+Home-page: https://github.com/AkmdAshraf/IBRAHIM
+Author: AkmdAshraf
+Author-email: AkmdAshraf <your-email@example.com>
+Maintainer-email: AkmdAshraf <your-email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AkmdAshraf/IBRAHIM
+Project-URL: Repository, https://github.com/AkmdAshraf/IBRAHIM
+Project-URL: Documentation, https://github.com/AkmdAshraf/IBRAHIM#readme
+Project-URL: Issues, https://github.com/AkmdAshraf/IBRAHIM/issues
+Keywords: benchmark,ranking,multi-criteria,decision-analysis,mcdm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: seaborn>=0.12.0
+Requires-Dist: scipy>=1.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# IBRAHIM (Intelligent Benchmark Relational Analysis for Heuristic Index Modeling)
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ibrahim.svg)](https://badge.fury.io/py/ibrahim)
+
+A novel machine learning framework for multi-criteria decision analysis and benchmark-based ranking.
+
+## 📊 Overview
+
+IBRAHIM is an intelligent analytical model that evaluates multiple records based on many variables, determines the highest benchmark, and computes ranking scores. It combines elements of multi-criteria decision analysis (MCDA) with machine learning for robust, automated benchmarking.
+
+### Key Features
+
+- **Automatic Feature Direction Detection**: Determines whether variables should be maximized or minimized
+- **Intelligent Benchmark Generation**: Creates ideal benchmark records based on feature directions
+- **Flexible Weight Assignment**: Supports both automatic (ML-based) and manual weight specification
+- **0-100 Scoring Scale**: Intuitive, normalized scores for easy interpretation
+- **New Record Evaluation**: Compare any new record against the established benchmark
+- **Visualization Tools**: Built-in plotting for ranking analysis
+
+## 🚀 Installation
+
+### From PyPI (once published)
+```bash
+pip install ibrahim

ibrahimpy-0.1.0/README.md

@@ -0,0 +1,26 @@
+# IBRAHIM (Intelligent Benchmark Relational Analysis for Heuristic Index Modeling)
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ibrahim.svg)](https://badge.fury.io/py/ibrahim)
+
+A novel machine learning framework for multi-criteria decision analysis and benchmark-based ranking.
+
+## 📊 Overview
+
+IBRAHIM is an intelligent analytical model that evaluates multiple records based on many variables, determines the highest benchmark, and computes ranking scores. It combines elements of multi-criteria decision analysis (MCDA) with machine learning for robust, automated benchmarking.
+
+### Key Features
+
+- **Automatic Feature Direction Detection**: Determines whether variables should be maximized or minimized
+- **Intelligent Benchmark Generation**: Creates ideal benchmark records based on feature directions
+- **Flexible Weight Assignment**: Supports both automatic (ML-based) and manual weight specification
+- **0-100 Scoring Scale**: Intuitive, normalized scores for easy interpretation
+- **New Record Evaluation**: Compare any new record against the established benchmark
+- **Visualization Tools**: Built-in plotting for ranking analysis
+
+## 🚀 Installation
+
+### From PyPI (once published)
+```bash
+pip install ibrahim

ibrahimpy-0.1.0/ibrahim/__init__.py

@@ -0,0 +1,17 @@
+"""IBRAHIM - Intelligent Benchmark Relational Analysis"""
+
+# These imports will work once all files are created
+from .model import IBRAHIM
+from .utils import normalize_data, detect_directions, calculate_weights
+from .visualization import plot_ranking, plot_feature_importance, plot_radar_comparison
+
+__version__ = "0.1.0"
+__all__ = [
+    "IBRAHIM",
+    "normalize_data", 
+    "detect_directions", 
+    "calculate_weights",
+    "plot_ranking", 
+    "plot_feature_importance", 
+    "plot_radar_comparison"
+]

ibrahimpy-0.1.0/ibrahim/model.py

@@ -0,0 +1,116 @@
+"""Core IBRAHIM model implementation"""
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+from sklearn.ensemble import RandomForestRegressor
+from scipy import stats
+
+class IBRAHIM:
+    def __init__(self, auto_weights=True, normalization='minmax', 
+                 distance_metric='euclidean', random_state=42):
+        self.auto_weights = auto_weights
+        self.normalization = normalization
+        self.distance_metric = distance_metric
+        self.random_state = random_state
+        self.is_fitted = False
+    
+    def fit(self, X, y=None, directions=None, weights=None):
+        self.feature_names_ = X.columns.tolist()
+        self.n_features_ = X.shape[1]
+        self.X_original_ = X.copy()
+        
+        # Simple minmax scaling for now
+        self.scaler_ = MinMaxScaler()
+        self.X_scaled_ = pd.DataFrame(
+            self.scaler_.fit_transform(X),
+            columns=X.columns,
+            index=X.index
+        )
+        
+        # Default directions (all max)
+        self.directions_ = {col: 'max' for col in self.feature_names_}
+        
+        # Simple benchmark
+        self.benchmark_ = {}
+        for col in self.feature_names_:
+            if self.directions_[col] == 'max':
+                self.benchmark_[col] = self.X_scaled_[col].max()
+            else:
+                self.benchmark_[col] = self.X_scaled_[col].min()
+        
+        # Simple weights (equal)
+        self.weights_ = {col: 1/self.n_features_ for col in self.feature_names_}
+        
+        self.is_fitted = True
+        return self
+    
+    def calculate_distances(self, X=None):
+        if X is None:
+            X_scaled = self.X_scaled_
+        else:
+            X_scaled = pd.DataFrame(
+                self.scaler_.transform(X),
+                columns=X.columns,
+                index=X.index
+            )
+        
+        distances = []
+        weight_vector = np.array([self.weights_[col] for col in self.feature_names_])
+        benchmark_vector = np.array([self.benchmark_[col] for col in self.feature_names_])
+        
+        for idx in X_scaled.index:
+            record = X_scaled.loc[idx].values
+            dist = np.sqrt(np.sum(weight_vector * (record - benchmark_vector)**2))
+            distances.append(dist)
+        
+        return np.array(distances)
+    
+    def rank(self, X=None):
+        distances = self.calculate_distances(X)
+        
+        if X is None:
+            ranking_df = self.X_original_.copy()
+        else:
+            ranking_df = X.copy()
+        
+        max_dist = distances.max()
+        min_dist = distances.min()
+        
+        if max_dist > min_dist:
+            scores = 100 * (1 - (distances - min_dist) / (max_dist - min_dist))
+        else:
+            scores = np.full_like(distances, 100)
+        
+        ranking_df['distance'] = distances
+        ranking_df['score'] = scores
+        ranking_df['rank'] = pd.Series(scores).rank(ascending=False, method='min').astype(int).values
+        
+        return ranking_df.sort_values('rank')
+    
+    def compare_new(self, new_record):
+        new_df = pd.DataFrame([new_record])
+        distance = self.calculate_distances(new_df)[0]
+        
+        existing = self.rank()
+        all_distances = np.append(existing['distance'].values, distance)
+        
+        max_dist = all_distances.max()
+        min_dist = all_distances.min()
+        
+        if max_dist > min_dist:
+            score = 100 * (1 - (distance - min_dist) / (max_dist - min_dist))
+        else:
+            score = 100
+        
+        return {'score': score, 'distance': distance}
+    
+    def get_summary(self):
+        ranking = self.rank()
+        return {
+            'n_features': self.n_features_,
+            'score_stats': {
+                'mean': ranking['score'].mean(),
+                'min': ranking['score'].min(),
+                'max': ranking['score'].max()
+            }
+        }

ibrahimpy-0.1.0/ibrahim/utils.py

@@ -0,0 +1,49 @@
+"""Utility functions for IBRAHIM"""
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler
+
+def normalize_data(X, method='minmax'):
+    """Normalize the input data"""
+    if method == 'minmax':
+        scaler = MinMaxScaler()
+    elif method == 'zscore':
+        scaler = StandardScaler()
+    elif method == 'robust':
+        scaler = RobustScaler()
+    else:
+        raise ValueError(f"Unknown method: {method}")
+    
+    X_scaled = pd.DataFrame(
+        scaler.fit_transform(X),
+        columns=X.columns,
+        index=X.index
+    )
+    return X_scaled, scaler
+
+def detect_directions(X_scaled, y=None, manual_directions=None):
+    """Determine feature directions"""
+    if manual_directions:
+        return manual_directions
+    
+    directions = {}
+    for col in X_scaled.columns:
+        directions[col] = 'max'  # Default
+    return directions
+
+def calculate_weights(X_scaled, y=None, manual_weights=None, auto_weights=True, random_state=42):
+    """Calculate feature weights"""
+    if manual_weights:
+        weights = manual_weights
+    elif auto_weights:
+        # Simple variance-based weights
+        variances = X_scaled.var()
+        weights = (variances / variances.sum()).to_dict()
+    else:
+        n_features = X_scaled.shape[1]
+        weights = {col: 1/n_features for col in X_scaled.columns}
+    
+    # Normalize
+    total = sum(weights.values())
+    weights = {k: v/total for k, v in weights.items()}
+    return weights

ibrahimpy-0.1.0/ibrahim/visualization.py

@@ -0,0 +1,31 @@
+"""Visualization functions for IBRAHIM"""
+import matplotlib.pyplot as plt
+import numpy as np
+
+def plot_ranking(model, top_n=10):
+    """Plot ranking results"""
+    ranking = model.rank()
+    
+    fig, ax = plt.subplots(figsize=(10, 6))
+    top_records = ranking.head(top_n)
+    
+    ax.barh(range(len(top_records)), top_records['score'].values[::-1])
+    ax.set_yticks(range(len(top_records)))
+    ax.set_yticklabels(top_records.index[::-1])
+    ax.set_xlabel('Score (0-100)')
+    ax.set_title(f'Top {top_n} Rankings')
+    ax.set_xlim(0, 100)
+    
+    plt.tight_layout()
+    plt.show()
+    return fig
+
+def plot_feature_importance(model):
+    """Plot feature importance"""
+    print("Feature importance plot - to be implemented")
+    return None
+
+def plot_radar_comparison(model, records=None):
+    """Plot radar comparison"""
+    print("Radar plot - to be implemented")
+    return None

ibrahimpy-0.1.0/ibrahimpy.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: ibrahimpy
+Version: 0.1.0
+Summary: Intelligent Benchmark Relational Analysis for Heuristic Index Modeling
+Home-page: https://github.com/AkmdAshraf/IBRAHIM
+Author: AkmdAshraf
+Author-email: AkmdAshraf <your-email@example.com>
+Maintainer-email: AkmdAshraf <your-email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/AkmdAshraf/IBRAHIM
+Project-URL: Repository, https://github.com/AkmdAshraf/IBRAHIM
+Project-URL: Documentation, https://github.com/AkmdAshraf/IBRAHIM#readme
+Project-URL: Issues, https://github.com/AkmdAshraf/IBRAHIM/issues
+Keywords: benchmark,ranking,multi-criteria,decision-analysis,mcdm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: seaborn>=0.12.0
+Requires-Dist: scipy>=1.10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# IBRAHIM (Intelligent Benchmark Relational Analysis for Heuristic Index Modeling)
+
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/ibrahim.svg)](https://badge.fury.io/py/ibrahim)
+
+A novel machine learning framework for multi-criteria decision analysis and benchmark-based ranking.
+
+## 📊 Overview
+
+IBRAHIM is an intelligent analytical model that evaluates multiple records based on many variables, determines the highest benchmark, and computes ranking scores. It combines elements of multi-criteria decision analysis (MCDA) with machine learning for robust, automated benchmarking.
+
+### Key Features
+
+- **Automatic Feature Direction Detection**: Determines whether variables should be maximized or minimized
+- **Intelligent Benchmark Generation**: Creates ideal benchmark records based on feature directions
+- **Flexible Weight Assignment**: Supports both automatic (ML-based) and manual weight specification
+- **0-100 Scoring Scale**: Intuitive, normalized scores for easy interpretation
+- **New Record Evaluation**: Compare any new record against the established benchmark
+- **Visualization Tools**: Built-in plotting for ranking analysis
+
+## 🚀 Installation
+
+### From PyPI (once published)
+```bash
+pip install ibrahim

ibrahimpy-0.1.0/ibrahimpy.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+setup.py
+ibrahim/__init__.py
+ibrahim/model.py
+ibrahim/utils.py
+ibrahim/visualization.py
+ibrahimpy.egg-info/PKG-INFO
+ibrahimpy.egg-info/SOURCES.txt
+ibrahimpy.egg-info/dependency_links.txt
+ibrahimpy.egg-info/requires.txt
+ibrahimpy.egg-info/top_level.txt
+tests/test_model.py

ibrahimpy-0.1.0/ibrahimpy.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ibrahimpy-0.1.0/ibrahimpy.egg-info/requires.txt

@@ -0,0 +1,14 @@
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scipy>=1.10.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=23.0.0
+flake8>=6.0.0
+build>=0.10.0
+twine>=4.0.0

ibrahimpy-0.1.0/ibrahimpy.egg-info/top_level.txt

@@ -0,0 +1 @@
+ibrahim

ibrahimpy-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ibrahimpy"
+version = "0.1.0"
+description = "Intelligent Benchmark Relational Analysis for Heuristic Index Modeling"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "AkmdAshraf", email = "your-email@example.com"},
+]
+maintainers = [
+    {name = "AkmdAshraf", email = "your-email@example.com"},
+]
+keywords = ["benchmark", "ranking", "multi-criteria", "decision-analysis", "mcdm"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "numpy>=1.24.0",
+    "pandas>=2.0.0",
+    "scikit-learn>=1.3.0",
+    "matplotlib>=3.7.0",
+    "seaborn>=0.12.0",
+    "scipy>=1.10.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "flake8>=6.0.0",
+    "build>=0.10.0",
+    "twine>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AkmdAshraf/IBRAHIM"
+Repository = "https://github.com/AkmdAshraf/IBRAHIM"
+Documentation = "https://github.com/AkmdAshraf/IBRAHIM#readme"
+Issues = "https://github.com/AkmdAshraf/IBRAHIM/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["ibrahim*"]
+exclude = ["tests*", "examples*"]
+
+[tool.setuptools.package-data]
+ibrahim = ["py.typed"]

ibrahimpy-0.1.0/requirements.txt

@@ -0,0 +1,6 @@
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+scipy>=1.10.0

ibrahimpy-0.1.0/setup.cfg

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

ibrahimpy-0.1.0/setup.py

@@ -0,0 +1,40 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith("#")]
+
+setup(
+    name="ibrahim",
+    version="0.1.0",
+    author="AkmdAshraf",
+    author_email="your-email@example.com",
+    description="Intelligent Benchmark Relational Analysis for Heuristic Index Modeling",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/AkmdAshraf/IBRAHIM",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Scientific/Engineering :: Information Analysis",
+    ],
+    python_requires=">=3.8",
+    install_requires=requirements,
+    extras_require={
+        "dev": [
+            "pytest>=7.0.0",
+            "pytest-cov>=4.0.0",
+            "black>=23.0.0",
+            "flake8>=6.0.0",
+        ],
+    },
+)

ibrahimpy-0.1.0/tests/test_model.py

@@ -0,0 +1,98 @@
+"""
+Unit tests for IBRAHIM model.
+"""
+
+import unittest
+import pandas as pd
+import numpy as np
+import sys
+import os
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from ibrahim import IBRAHIM
+
+class TestIBRAHIM(unittest.TestCase):
+    """Test cases for IBRAHIM model"""
+    
+    def setUp(self):
+        """Set up test data"""
+        self.data = pd.DataFrame({
+            'A': [1, 2, 3, 4, 5],
+            'B': [5, 4, 3, 2, 1],
+            'C': [2, 3, 4, 5, 6]
+        })
+        
+    def test_initialization(self):
+        """Test model initialization"""
+        model = IBRAHIM(auto_weights=True)
+        self.assertEqual(model.auto_weights, True)
+        self.assertEqual(model.normalization, 'minmax')
+        self.assertEqual(model.distance_metric, 'euclidean')
+        
+    def test_fit_and_rank(self):
+        """Test fitting and ranking"""
+        model = IBRAHIM(auto_weights=True)
+        model.fit(self.data)
+        
+        rankings = model.rank()
+        
+        self.assertIn('score', rankings.columns)
+        self.assertIn('rank', rankings.columns)
+        self.assertIn('distance', rankings.columns)
+        self.assertEqual(len(rankings), len(self.data))
+        
+    def test_compare_new(self):
+        """Test comparing new record"""
+        model = IBRAHIM(auto_weights=True)
+        model.fit(self.data)
+        
+        new_record = {'A': 3, 'B': 3, 'C': 4}
+        result = model.compare_new(new_record)
+        
+        self.assertIn('score', result)
+        self.assertIn('distance', result)
+        self.assertIn('benchmark_comparison', result)
+        
+    def test_directions(self):
+        """Test manual directions"""
+        model = IBRAHIM(auto_weights=False)
+        directions = {'A': 'max', 'B': 'min', 'C': 'max'}
+        model.fit(self.data, directions=directions)
+        
+        self.assertEqual(model.directions_, directions)
+        
+    def test_weights(self):
+        """Test manual weights"""
+        model = IBRAHIM(auto_weights=False)
+        weights = {'A': 0.5, 'B': 0.3, 'C': 0.2}
+        model.fit(self.data, weights=weights)
+        
+        # Weights should be normalized
+        self.assertAlmostEqual(sum(model.weights_.values()), 1.0)
+        
+    def test_score_range(self):
+        """Test scores are between 0 and 100"""
+        model = IBRAHIM(auto_weights=True)
+        model.fit(self.data)
+        
+        rankings = model.rank()
+        
+        self.assertTrue(all(rankings['score'] >= 0))
+        self.assertTrue(all(rankings['score'] <= 100))
+        
+    def test_different_normalizations(self):
+        """Test different normalization methods"""
+        for norm in ['minmax', 'zscore', 'robust']:
+            model = IBRAHIM(normalization=norm)
+            model.fit(self.data)
+            self.assertEqual(model.normalization, norm)
+            
+    def test_different_distances(self):
+        """Test different distance metrics"""
+        for metric in ['euclidean', 'manhattan']:
+            model = IBRAHIM(distance_metric=metric)
+            model.fit(self.data)
+            self.assertEqual(model.distance_metric, metric)
+
+if __name__ == '__main__':
+    unittest.main()