diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 8d487ac..eb96306 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -24,6 +24,7 @@ jobs:
         python -m pip install --upgrade pip
         pip install -r requirements.txt
         pip install pylint
+        pip install pytest pytest-cov
         pip install .
         
     - name: Lint with pylint
@@ -32,5 +33,9 @@ jobs:
 
     - name: Run tests with pytest
       run: |
-        pip install pytest
-        pytest
+        pytest --cov
+
+    - name: Upload results to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
diff --git a/build/lib/eclipsebin/__init__.py b/build/lib/eclipsebin/__init__.py
new file mode 100644
index 0000000..6fd7836
--- /dev/null
+++ b/build/lib/eclipsebin/__init__.py
@@ -0,0 +1,5 @@
+"""
+This module initializes the Eclipsing Binary Binner.
+"""
+
+from .binning import EclipsingBinaryBinner
diff --git a/build/lib/eclipsebin/binning.py b/build/lib/eclipsebin/binning.py
new file mode 100644
index 0000000..5098046
--- /dev/null
+++ b/build/lib/eclipsebin/binning.py
@@ -0,0 +1,331 @@
+"""
+This module contains the EclipsingBinaryBinner class, which performs non-uniform binning
+of eclipsing binary star light curves.
+"""
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+import matplotlib.pyplot as plt
+
+
+class EclipsingBinaryBinner:
+    """
+    A class to perform non-uniform binning of eclipsing binary star light curves.
+
+    This class identifies primary and secondary eclipses within the light curve
+    and allocates bins to better capture these eclipse events, while also binning
+    the out-of-eclipse regions.
+
+    Attributes:
+        data (dict): Dictionary containing the light curve data.
+        params (dict): Dictionary containing the binning parameters.
+        primary_eclipse_min_phase (float): Phase value of the primary eclipse minimum.
+        secondary_eclipse_min_phase (float): Phase value of the secondary eclipse minimum.
+        primary_eclipse (tuple): Start and end phase values of the primary eclipse.
+        secondary_eclipse (tuple): Start and end phase values of the secondary eclipse.
+    """
+
+    def __init__(self, phases, fluxes, flux_errors, nbins=200, fraction_in_eclipse=0.2):
+        """
+        Initializes the EclipsingBinaryBinner with the given light curve data and parameters.
+
+        Args:
+            phases (np.ndarray): Array of phase values.
+            fluxes (np.ndarray): Array of flux values.
+            flux_errors (np.ndarray): Array of flux errors.
+            nbins (int, optional): Number of bins to use. Defaults to 200.
+            fraction_in_eclipse (float, optional): Fraction of bins within eclipses. 
+                Defaults to 0.2.
+
+        Raises:
+            ValueError: If the number of data points is less than 10, or if the number of bins 
+                is less than 10, or if the number of data points is less than the number of bins.
+        """
+        if len(phases) < 10:
+            raise ValueError("Number of data points must be at least 10.")
+        if nbins < 10:
+            raise ValueError("Number of bins must be at least 10.")
+        if len(phases) < nbins:
+            raise ValueError(
+                "Number of data points must be greater than or equal to the number of bins."
+            )
+
+        self.data = {
+            'phases': phases,
+            'fluxes': fluxes,
+            'flux_errors': flux_errors
+        }
+        self.params = {
+            'nbins': nbins,
+            'fraction_in_eclipse': fraction_in_eclipse
+        }
+
+        # Identify primary and secondary eclipse minima
+        self.primary_eclipse_min_phase = self.find_minimum_flux()
+        self.secondary_eclipse_min_phase = self.find_secondary_minimum()
+
+        # Determine start and end of each eclipse
+        self.primary_eclipse = self.get_eclipse_boundaries(
+            self.primary_eclipse_min_phase
+        )
+        self.secondary_eclipse = self.get_eclipse_boundaries(
+            self.secondary_eclipse_min_phase
+        )
+
+    def find_minimum_flux(self):
+        """
+        Finds the phase of the minimum flux, corresponding to the primary eclipse.
+
+        Returns:
+            float: Phase value of the primary eclipse minimum.
+        """
+        idx_min = np.argmin(self.data['fluxes'])
+        return self.data['phases'][idx_min]
+
+    def find_secondary_minimum(self):
+        """
+        Finds the phase of the secondary eclipse by identifying the minimum flux
+        at least 0.2 phase units away from the primary eclipse.
+
+        Returns:
+            float: Phase value of the secondary eclipse minimum.
+        """
+        mask = np.abs(self.data['phases'] - self.primary_eclipse_min_phase) > 0.2
+        idx_secondary_min = np.argmin(self.data['fluxes'][mask])
+        return self.data['phases'][mask][idx_secondary_min]
+
+    def get_eclipse_boundaries(self, eclipse_min_phase):
+        """
+        Finds the start and end phase of an eclipse based on the minimum flux.
+
+        Args:
+            eclipse_min_phase (float): Phase of the minimum flux.
+
+        Returns:
+            tuple: Start and end phases of the eclipse.
+        """
+        start_idx, end_idx = self._find_eclipse_boundaries(eclipse_min_phase)
+        return (self.data['phases'][start_idx], self.data['phases'][end_idx])
+
+    def _find_eclipse_boundaries(self, eclipse_min_phase):
+        """
+        Determines the start and end indices of an eclipse.
+
+        Args:
+            eclipse_min_phase (float): Phase of the minimum flux.
+
+        Returns:
+            tuple: Indices of the start and end of the eclipse.
+        """
+        start_idx = self._find_eclipse_boundary(eclipse_min_phase, direction="start")
+        end_idx = self._find_eclipse_boundary(eclipse_min_phase, direction="end")
+        return start_idx, end_idx
+
+    def _find_eclipse_boundary(self, eclipse_min_phase, direction):
+        """
+        Finds the boundary index of an eclipse either before (start) or after (end) 
+            the minimum flux.
+
+        Args:
+            eclipse_min_phase (float): Phase of the minimum flux.
+            direction (str): Direction to search ('start' or 'end').
+
+        Returns:
+            int: Index of the boundary point.
+        """
+        if direction == "start":
+            mask = self.data['phases'] < eclipse_min_phase
+        else:  # direction == 'end'
+            mask = self.data['phases'] > eclipse_min_phase
+
+        idx_boundary = np.where(mask & np.isclose(self.data['fluxes'], 1.0, atol=0.01))[0]
+
+        if len(idx_boundary) == 0:
+            # If no boundary found, use the closest point to 1.0 flux
+            if direction == "start":
+                return np.where(np.isclose(self.data['fluxes'], 1.0, atol=0.01))[0][-1]
+            return np.where(np.isclose(self.data['fluxes'], 1.0, atol=0.01))[0][0]
+        # Return the last or first index depending on direction
+        return idx_boundary[-1] if direction == "start" else idx_boundary[0]
+
+    def calculate_bins(self):
+        """
+        Calculates the bin centers, means, and standard deviations for the binned light curve.
+
+        Returns:
+            tuple: Arrays of bin centers, bin means, bin standard deviations, bin numbers, 
+                and bin edges.
+        """
+        bins_in_primary = int((self.params['nbins'] * self.params['fraction_in_eclipse']) / 2)
+        bins_in_secondary = int(
+            (self.params['nbins'] * self.params['fraction_in_eclipse']) - bins_in_primary
+        )
+
+        primary_bin_edges = self.calculate_eclipse_bins(
+            self.primary_eclipse, bins_in_primary
+        )
+        secondary_bin_edges = self.calculate_eclipse_bins(
+            self.secondary_eclipse, bins_in_secondary
+        )
+
+        ooe1_bins, ooe2_bins = self.calculate_out_of_eclipse_bins(
+            bins_in_primary, bins_in_secondary
+        )
+
+        all_bins = np.sort(
+            np.concatenate(
+                (primary_bin_edges, secondary_bin_edges, ooe1_bins, ooe2_bins)
+            )
+        )
+        bin_means, bin_edges, bin_number = stats.binned_statistic(
+            self.data['phases'], self.data['fluxes'], statistic="mean", bins=all_bins
+        )
+        bin_centers = (bin_edges[1:] - bin_edges[:-1]) / 2 + bin_edges[:-1]
+        bin_stds, _, bin_number = stats.binned_statistic(
+            self.data['phases'], self.data['fluxes'], statistic="std", bins=all_bins
+        )
+
+        return bin_centers, bin_means, bin_stds, bin_number, bin_edges
+
+    def calculate_eclipse_bins(self, eclipse_boundaries, bins_in_eclipse):
+        """
+        Calculates bin edges within an eclipse.
+
+        Args:
+            eclipse_boundaries (tuple): Start and end phases of the eclipse.
+            bins_in_eclipse (int): Number of bins within the eclipse.
+
+        Returns:
+            np.ndarray: Array of bin edges within the eclipse.
+        """
+        start_idx, end_idx = np.searchsorted(self.data['phases'], eclipse_boundaries)
+        eclipse_phases = (
+            np.concatenate(
+                (self.data['phases'][start_idx:], self.data['phases'][: end_idx + 1] + 1)
+            )
+            if end_idx < start_idx
+            else self.data['phases'][start_idx : end_idx + 1]
+        )
+        bins = pd.qcut(eclipse_phases, q=bins_in_eclipse)
+        return np.array([interval.right for interval in np.unique(bins)]) % 1
+
+    def calculate_out_of_eclipse_bins(self, bins_in_primary, bins_in_secondary):
+        """
+        Calculates bin edges for out-of-eclipse regions.
+
+        Args:
+            bins_in_primary (int): Number of bins in the primary eclipse.
+            bins_in_secondary (int): Number of bins in the secondary eclipse.
+
+        Returns:
+            tuple: Arrays of bin edges for the two out-of-eclipse regions.
+        """
+        bins_in_ooe1 = int((self.params['nbins'] - bins_in_primary - bins_in_secondary) / 2)
+        bins_in_ooe2 = self.params['nbins'] - bins_in_primary - bins_in_secondary - bins_in_ooe1
+
+        ooe1_bins = pd.qcut(
+            np.concatenate(
+                (
+                    self.data['phases'][
+                        np.searchsorted(self.data['phases'], self.secondary_eclipse[1]) :
+                    ],
+                    self.data['phases'][
+                        : np.searchsorted(self.data['phases'], self.primary_eclipse[0])
+                    ] + 1,
+                )
+            ),
+            q=bins_in_ooe1,
+        )
+        ooe1_edges = (
+            np.array([interval.right for interval in np.unique(ooe1_bins)])[:-1] % 1
+        )
+
+        ooe2_bins = pd.qcut(
+            np.concatenate(
+                (
+                    self.data['phases'][
+                        np.searchsorted(self.data['phases'], self.primary_eclipse[1]) :
+                    ],
+                    self.data['phases'][
+                        : np.searchsorted(self.data['phases'], self.secondary_eclipse[0])
+                    ] + 1,
+                )
+            ),
+            q=bins_in_ooe2 + 2,
+        )
+        ooe2_edges = (
+            np.array([interval.right for interval in np.unique(ooe2_bins)])[:-1] % 1
+        )
+
+        return ooe1_edges, ooe2_edges
+
+    def plot_binned_light_curve(self, bin_centers, bin_means, bin_stds, bin_edges):
+        """
+        Plots the binned light curve and the bin edges.
+
+        Args:
+            bin_centers (np.ndarray): Array of bin centers.
+            bin_means (np.ndarray): Array of bin means.
+            bin_stds (np.ndarray): Array of bin standard deviations.
+            bin_edges (np.ndarray): Array of bin edges.
+        """
+        plt.figure(figsize=(20, 5))
+        plt.errorbar(bin_centers, bin_means, yerr=bin_stds, fmt=".", color="red")
+        plt.scatter(self.data['phases'], self.data['fluxes'], s=20)
+        plt.vlines(
+            self.primary_eclipse, ymin=0.6, ymax=1.1, linestyle="--", color="red"
+        )
+        plt.vlines(
+            self.secondary_eclipse, ymin=0.6, ymax=1.1, linestyle="--", color="red"
+        )
+        plt.vlines(bin_edges, ymin=0.6, ymax=1.1, linestyle="--", color="green")
+        plt.ylim(0.8, 1.05)
+        plt.xlim(0.97, 1.001)
+        plt.show()
+
+    def plot_unbinned_light_curve(self):
+        """
+        Plots the unbinned light curve with the calculated eclipse minima and bin edges.
+        """
+        plt.figure(figsize=(20, 5))
+        plt.scatter(self.data['phases'], self.data['fluxes'], s=3)
+        plt.scatter(self.primary_eclipse_min_phase, min(self.data['fluxes']), c="red", s=5)
+        plt.scatter(
+            self.secondary_eclipse_min_phase,
+            min(
+                self.data['fluxes'][
+                    np.abs(self.data['phases'] - self.secondary_eclipse_min_phase) > 0.2
+                ]
+            ),
+            c="red",
+            s=5,
+        )
+        plt.vlines(
+            self.primary_eclipse, ymin=0.6, ymax=1.1, linestyle="--", color="red"
+        )
+        plt.vlines(
+            self.secondary_eclipse, ymin=0.6, ymax=1.1, linestyle="--", color="red"
+        )
+        plt.ylim(0.8, 1.05)
+        plt.show()
+
+    def bin_light_curve(self, plot=True):
+        """
+        Bins the light curve data and optionally plots the results.
+
+        Args:
+            plot (bool, optional): Whether to plot the binned and unbinned light curves. 
+             Defaults to True.
+
+        Returns:
+            tuple: Arrays of bin centers, bin means, and bin standard deviations.
+        """
+        bin_centers, bin_means, bin_stds, _, bin_edges = self.calculate_bins()
+
+        if plot:
+            self.plot_binned_light_curve(bin_centers, bin_means, bin_stds, bin_edges)
+            self.plot_unbinned_light_curve()
+
+        return bin_centers, bin_means, bin_stds
+    
\ No newline at end of file
diff --git a/build/lib/tests/__init__.py b/build/lib/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/build/lib/tests/test_eclipsing_binary_binner.py b/build/lib/tests/test_eclipsing_binary_binner.py
new file mode 100644
index 0000000..f143351
--- /dev/null
+++ b/build/lib/tests/test_eclipsing_binary_binner.py
@@ -0,0 +1,182 @@
+"""
+Unit tests for the EclipsingBinaryBinner class from the eclipsebin module.
+"""
+
+import numpy as np
+import pytest
+from eclipsebin import EclipsingBinaryBinner
+
+import matplotlib
+
+matplotlib.use("Agg")
+
+
+def test_initialization():
+    '''
+    This test function checks if the EclipsingBinaryBinner class is initialized correctly
+    with the given input parameters. It verifies:
+    1. The correct assignment of input parameters to class attributes.
+    2. The proper handling of array inputs (phases, fluxes, and flux_errors).
+    3. The initialization of other necessary attributes.
+
+    The test creates an instance of EclipsingBinaryBinner with sample data and custom
+    parameters, then asserts that the instance's attributes match the expected values.
+    '''
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.random.normal(1, 0.01, 100)
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    binner = EclipsingBinaryBinner(
+        phases, fluxes, flux_errors, nbins=50, fraction_in_eclipse=0.3
+    )
+
+    assert binner.params['nbins'] == 50
+    assert binner.params['fraction_in_eclipse'] == 0.3
+    assert len(binner.data['phases']) == 100
+    assert len(binner.data['fluxes']) == 100
+    assert len(binner.data['flux_errors']) == 100
+
+def test_initialization_valid_data():
+    '''
+    This test function verifies that the EclipsingBinaryBinner class initializes correctly
+    with valid input data. It checks:
+    1. The correct assignment of input parameters to class attributes.
+    2. The proper handling of array inputs (phases, fluxes, and flux_errors).
+    3. The initialization of other necessary attributes.
+
+    The test creates an instance of EclipsingBinaryBinner with sample data and custom
+    parameters, then asserts that the instance's attributes match the expected values.
+    This test is similar to test_initialization, but focuses specifically on valid data inputs.
+    '''
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.random.normal(1, 0.01, 100)
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    binner = EclipsingBinaryBinner(
+        phases, fluxes, flux_errors, nbins=50, fraction_in_eclipse=0.3
+    )
+
+    assert binner.params['nbins'] == 50
+    assert binner.params['fraction_in_eclipse'] == 0.3
+    assert len(binner.data['phases']) == 100
+    assert len(binner.data['fluxes']) == 100
+    assert len(binner.data['flux_errors']) == 100
+
+def test_initialization_invalid_data():
+    '''
+    This test function verifies that the EclipsingBinaryBinner class raises appropriate
+    ValueError exceptions when initialized with invalid input data. It checks:
+    1. The case when the number of data points is less than 10.
+    2. The case when the number of bins is less than 10.
+    3. The case when the number of data points is less than the number of bins.
+
+    For each case, the test creates an instance of EclipsingBinaryBinner with invalid
+    input data and asserts that the correct ValueError is raised with the expected
+    error message.
+    '''
+    # Fewer than 10 data points
+    phases = np.linspace(0, 1, 9)
+    fluxes = np.random.normal(1, 0.01, 9)
+    flux_errors = np.random.normal(0.01, 0.001, 9)
+
+    with pytest.raises(ValueError, match="Number of data points must be at least 10."):
+        EclipsingBinaryBinner(phases, fluxes, flux_errors, nbins=10)
+
+    # Fewer than 10 bins
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.random.normal(1, 0.01, 100)
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    with pytest.raises(ValueError, match="Number of bins must be at least 10."):
+        EclipsingBinaryBinner(phases, fluxes, flux_errors, nbins=9)
+
+    # Data points fewer than bins
+    with pytest.raises(
+        ValueError,
+        match="Number of data points must be greater than or equal to the number of bins.",
+    ):
+        EclipsingBinaryBinner(phases[:50], fluxes[:50], flux_errors[:50], nbins=60)
+
+
+def test_eclipse_detection():
+    '''
+    This test function verifies the eclipse detection capabilities of the 
+    EclipsingBinaryBinner class.
+    It checks:
+    1. The ability to correctly identify the primary eclipse minimum.
+    2. The ability to determine the boundaries of the primary eclipse.
+    3. The correct placement of the primary eclipse minimum within the detected boundaries.
+
+    The test creates a simulated light curve with a single eclipse, initializes an
+    EclipsingBinaryBinner instance with this data, and then asserts that the detected
+    eclipse properties match the expected values.
+    '''
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.ones_like(phases)
+    fluxes[45:55] = 0.9  # Simulate primary eclipse
+    fluxes[0:3] = 0.95 # Simulate secondary eclipse
+    fluxes[97:100] = 0.95 # Wrap secondary eclipse
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    binner = EclipsingBinaryBinner(phases, fluxes, flux_errors, nbins=50)
+
+    # Ensure that find_minimum_flux returns a single value
+    primary_min = binner.find_minimum_flux()
+    assert np.isscalar(primary_min), "find_minimum_flux should return a single value"
+    assert np.isclose(primary_min, 0.45, atol=0.05)
+    primary_eclipse = binner.get_eclipse_boundaries(primary_min)
+    assert primary_eclipse[0] < primary_min < primary_eclipse[1]
+
+
+def test_bin_calculation():
+    '''
+    This test function verifies the bin calculation capabilities of the EclipsingBinaryBinner class.
+    It checks:
+    1. The correct calculation of bin centers.
+    2. The correct calculation of bin means.
+    3. The correct calculation of bin standard deviations.
+
+    The test creates a simulated light curve with a single eclipse, initializes an
+    EclipsingBinaryBinner instance with this data, and then asserts that the calculated
+    bin properties match the expected values.
+    '''
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.ones_like(phases)
+    fluxes[45:55] = 0.9  # Simulate an eclipse
+    fluxes[0:3] = 0.95 # Simulate secondary eclipse
+    fluxes[97:100] = 0.95 # Wrap secondary eclipse
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    binner = EclipsingBinaryBinner(phases, fluxes, flux_errors, nbins=50)
+
+    bin_centers, bin_means, bin_stds = binner.bin_light_curve(plot=False)
+
+    assert len(bin_centers) > 0
+    assert len(bin_means) == len(bin_centers)
+    assert len(bin_stds) == len(bin_centers)
+
+
+def test_plot_functions():
+    '''
+    This test function verifies the plotting capabilities of the EclipsingBinaryBinner class.
+    It checks:
+    1. The ability to plot the binned light curve.
+    2. The ability to plot the unbinned light curve.
+
+    The test creates a simulated light curve with a single eclipse, initializes an
+    EclipsingBinaryBinner instance with this data, and then asserts that the plotting
+    functions run without error.
+    '''
+    phases = np.linspace(0, 1, 100)
+    fluxes = np.ones_like(phases)
+    fluxes[45:55] = 0.9  # Simulate an eclipse
+    fluxes[0:3] = 0.95 # Simulate secondary eclipse
+    fluxes[97:100] = 0.95 # Wrap secondary eclipse
+    flux_errors = np.random.normal(0.01, 0.001, 100)
+
+    binner = EclipsingBinaryBinner(phases, fluxes, flux_errors, nbins=50)
+
+    # Ensure plotting functions run without error
+    bin_centers, bin_means, bin_stds = binner.bin_light_curve(plot=True)
+    binner.plot_binned_light_curve(bin_centers, bin_means, bin_stds, bin_centers)
+    binner.plot_unbinned_light_curve()
diff --git a/dist/eclipsebin-0.1.0-py3-none-any.whl b/dist/eclipsebin-0.1.0-py3-none-any.whl
new file mode 100644
index 0000000..6fa33da
Binary files /dev/null and b/dist/eclipsebin-0.1.0-py3-none-any.whl differ
diff --git a/dist/eclipsebin-0.1.0.tar.gz b/dist/eclipsebin-0.1.0.tar.gz
new file mode 100644
index 0000000..1d52da7
Binary files /dev/null and b/dist/eclipsebin-0.1.0.tar.gz differ
diff --git a/eclipsebin.egg-info/PKG-INFO b/eclipsebin.egg-info/PKG-INFO
new file mode 100644
index 0000000..e433b94
--- /dev/null
+++ b/eclipsebin.egg-info/PKG-INFO
@@ -0,0 +1,67 @@
+Metadata-Version: 2.1
+Name: eclipsebin
+Version: 0.1.0
+Summary: A specialized binning scheme for eclipsing binary star light curves
+Home-page: https://github.com/jackieblaum/eclipsebin
+Author: Jackie Blaum
+Author-email: jackie.blaum@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+## Binning Eclipsing Binary Star Light Curves
+
+![Build Status](https://github.com/jackieblaum/eclipsebin/actions/workflows/tests.yml/badge.svg)
+![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)
+![Python Versions](https://img.shields.io/pypi/pyversions/eclipsebin)
+![PyPI Version](https://img.shields.io/pypi/v/eclipsebin)
+![Coverage](https://codecov.io/gh/jackieblaum/eclipsebin/branch/main/graph/badge.svg)
+
+![Binned Light Curve](docs/images/binning_comparison.jpg)
+
+### Overview
+
+This Python package provides a specialized binning scheme designed to more effectively capture the features of eclipsing binary star light curves. Unlike **traditional uniform binning (middle panel)**, which can dilute the crucial details of eclipses, this **non-uniform binning method (right panel)** prioritizes the accurate representation of eclipse events.
+
+### Key Features
+
+- **Eclipse-Focused Binning**: The binning algorithm identifies the eclipse phases and allocates up to half of the total bins to these critical periods. The remaining bins are distributed across the out-of-eclipse regions.
+  
+- **Optimized Data Distribution**: Using the `pandas qcut` function, the package ensures that each bin within the eclipse and out-of-eclipse segments contains approximately the same number of data points, maintaining the integrity of the light curve's structure.
+  
+- **Enhanced Accuracy**: By concentrating bins around the brief, narrow eclipse phases, the method improves the resolution of these events, which are essential for deriving accurate parameters of the binary system.
+
+### Why Use This Binning Scheme?
+
+Eclipses in binary star systems contain vital information about the system's properties, such as the relative sizes, masses, and orbital parameters of the stars. Standard uniform binning can obscure these details, especially when the eclipse duration is short relative to the orbital period. This package mitigates that issue by adaptively placing more bins where they matter most—during the eclipses—thereby preserving the fidelity of the light curve and improving the subsequent analysis.
+
+### Getting Started
+
+To start using the package, install it via pip:
+
+```bash
+pip install eclipsebin
+```
+
+### Usage
+
+```bash
+import eclipsebin as ebin
+
+# Example usage
+binner = EclipsingBinaryBinner(phases, fluxes, fluxerrs, nbins=200, frac_in_ecl=0.2)
+bin_centers, bin_means, bin_stds = binner.bin_light_curve(plot=True)
+```
+
+Refer to the [documentation](https://github.com/yourusername/your-package-name) for more detailed usage instructions and examples.
+
+### Contributing
+
+Contributions are welcome! Please refer to the [Contributing Guide](CONTRIBUTING.md) for guidelines on how to help improve this project.
+
+### License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
diff --git a/eclipsebin.egg-info/SOURCES.txt b/eclipsebin.egg-info/SOURCES.txt
new file mode 100644
index 0000000..d3e1102
--- /dev/null
+++ b/eclipsebin.egg-info/SOURCES.txt
@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+eclipsebin/__init__.py
+eclipsebin/binning.py
+eclipsebin.egg-info/PKG-INFO
+eclipsebin.egg-info/SOURCES.txt
+eclipsebin.egg-info/dependency_links.txt
+eclipsebin.egg-info/requires.txt
+eclipsebin.egg-info/top_level.txt
+tests/__init__.py
+tests/test_eclipsing_binary_binner.py
\ No newline at end of file
diff --git a/eclipsebin.egg-info/dependency_links.txt b/eclipsebin.egg-info/dependency_links.txt
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/eclipsebin.egg-info/dependency_links.txt
@@ -0,0 +1 @@
+
diff --git a/eclipsebin.egg-info/requires.txt b/eclipsebin.egg-info/requires.txt
new file mode 100644
index 0000000..439a27a
--- /dev/null
+++ b/eclipsebin.egg-info/requires.txt
@@ -0,0 +1,4 @@
+numpy
+pandas
+scipy
+matplotlib
diff --git a/eclipsebin.egg-info/top_level.txt b/eclipsebin.egg-info/top_level.txt
new file mode 100644
index 0000000..885ed97
--- /dev/null
+++ b/eclipsebin.egg-info/top_level.txt
@@ -0,0 +1,2 @@
+eclipsebin
+tests
diff --git a/eclipsebin/__pycache__/__init__.cpython-311.pyc b/eclipsebin/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000..e4b6a31
Binary files /dev/null and b/eclipsebin/__pycache__/__init__.cpython-311.pyc differ
diff --git a/eclipsebin/__pycache__/binning.cpython-311.pyc b/eclipsebin/__pycache__/binning.cpython-311.pyc
new file mode 100644
index 0000000..6f708b5
Binary files /dev/null and b/eclipsebin/__pycache__/binning.cpython-311.pyc differ