How to use the astroplan.constraints.Constraint function in astroplan

def __init__(self, eclipsing_system):
        """
        Parameters
        ----------
        eclipsing_system : `~astroplan.periodic.EclipsingSystem`
            System which must be in secondary eclipse.
        """
        self.eclipsing_system = eclipsing_system

    def compute_constraint(self, times, observer=None, targets=None):
        mask = self.eclipsing_system.in_secondary_eclipse(times)
        return mask


class PhaseConstraint(Constraint):
    """
    Constrain observations to times in some range of phases for a periodic event
    (e.g.~transiting exoplanets, eclipsing binaries).
    """

    def __init__(self, periodic_event, min=None, max=None):
        """
        Parameters
        ----------
        periodic_event : `~astroplan.periodic.PeriodicEvent` or subclass
            System on which to compute the phase. For example, the system
            could be an eclipsing or non-eclipsing binary, or exoplanet system.
        min : float (optional)
            Minimum phase (inclusive) on interval [0, 1). Default is zero.
        max : float (optional)
            Maximum phase (inclusive) on interval [0, 1). Default is one.

altitude=altitude)
            finally:
                if self.force_pressure_zero:
                    observer.pressure = observer_old_pressure
        else:
            altitude = observer._altaz_cache[aakey]['altitude']

        return altitude

    def compute_constraint(self, times, observer, targets):
        solar_altitude = self._get_solar_altitudes(times, observer, targets)
        mask = solar_altitude <= self.max_solar_altitude
        return mask


class GalacticLatitudeConstraint(Constraint):
    """
    Constrain the distance between the Galactic plane and some targets.
    """

    def __init__(self, min=None, max=None):
        """
        Parameters
        ----------
        min : `~astropy.units.Quantity` or `None` (optional)
            Minimum acceptable Galactic latitude of target (inclusive).
            `None` indicates no limit.
        max : `~astropy.units.Quantity` or `None` (optional)
            Minimum acceptable Galactic latitude of target (inclusive).
            `None` indicates no limit.
        """
        self.min = min

illumination = cached_moon['illum']
        if self.min is None and self.max is not None:
            mask = (self.max >= illumination) | moon_down_mask
        elif self.max is None and self.min is not None:
            mask = (self.min <= illumination) & moon_up_mask
        elif self.min is not None and self.max is not None:
            mask = ((self.min <= illumination) &
                    (illumination <= self.max)) & moon_up_mask
        else:
            raise ValueError("No max and/or min specified in "
                             "MoonSeparationConstraint.")

        return mask


class LocalTimeConstraint(Constraint):
    """
    Constrain the observable hours.
    """

    def __init__(self, min=None, max=None):
        """
        Parameters
        ----------
        min : `~datetime.time`
            Earliest local time (inclusive). `None` indicates no limit.

        max : `~datetime.time`
            Latest local time (inclusive). `None` indicates no limit.

        Examples
        --------

else:
                raise ValueError("No max and/or min specified in "
                                 "AirmassConstraint.")
            return mask
        else:
            if self.max is None:
                raise ValueError("Cannot have a float AirmassConstraint if max is None.")
            else:
                mx = self.max

            mi = 1 if self.min is None else self.min
            # values below 1 should be disregarded
            return min_best_rescale(secz, mi, mx, less_than_min=0)


class AtNightConstraint(Constraint):
    """
    Constrain the Sun to be below ``horizon``.
    """
    @u.quantity_input(horizon=u.deg)
    def __init__(self, max_solar_altitude=0*u.deg, force_pressure_zero=True):
        """
        Parameters
        ----------
        max_solar_altitude : `~astropy.units.Quantity`
            The altitude of the sun below which it is considered to be "night"
            (inclusive).
        force_pressure_zero : bool (optional)
            Force the pressure to zero for solar altitude calculations. This
            avoids errors in the altitude of the Sun that can occur when the
            Sun is below the horizon and the corrections for atmospheric
            refraction return nonsense values.

if self.max is not None:
            if not isinstance(self.max, Time):
                raise TypeError("Time limits must be specified as "
                                "astropy.time.Time objects.")

    def compute_constraint(self, times, observer, targets):
        with warnings.catch_warnings():
            warnings.simplefilter('ignore')
            min_time = Time("1950-01-01T00:00:00") if self.min is None else self.min
            max_time = Time("2120-01-01T00:00:00") if self.max is None else self.max
        mask = np.logical_and(times > min_time, times < max_time)
        return mask


class PrimaryEclipseConstraint(Constraint):
    """
    Constrain observations to times during primary eclipse.
    """

    def __init__(self, eclipsing_system):
        """
        Parameters
        ----------
        eclipsing_system : `~astroplan.periodic.EclipsingSystem`
            System which must be in primary eclipse.
        """
        self.eclipsing_system = eclipsing_system

    def compute_constraint(self, times, observer=None, targets=None):
        mask = self.eclipsing_system.in_primary_eclipse(times)
        return mask

solar_separation = sun.separation(targets)

        if self.min is None and self.max is not None:
            mask = self.max >= solar_separation
        elif self.max is None and self.min is not None:
            mask = self.min <= solar_separation
        elif self.min is not None and self.max is not None:
            mask = ((self.min <= solar_separation) &
                    (solar_separation <= self.max))
        else:
            raise ValueError("No max and/or min specified in "
                             "SunSeparationConstraint.")
        return mask


class MoonSeparationConstraint(Constraint):
    """
    Constrain the distance between the Earth's moon and some targets.
    """

    def __init__(self, min=None, max=None, ephemeris=None):
        """
        Parameters
        ----------
        min : `~astropy.units.Quantity` or `None` (optional)
            Minimum acceptable separation between moon and target (inclusive).
            `None` indicates no limit.
        max : `~astropy.units.Quantity` or `None` (optional)
            Maximum acceptable separation between moon and target (inclusive).
            `None` indicates no limit.
        ephemeris : str, optional
            Ephemeris to use.  If not given, use the one set with

def compute_constraint(self, times, observer, targets):
        separation = abs(targets.transform_to(Galactic).b)

        if self.min is None and self.max is not None:
            mask = self.max >= separation
        elif self.max is None and self.min is not None:
            mask = self.min <= separation
        elif self.min is not None and self.max is not None:
            mask = ((self.min <= separation) & (separation <= self.max))
        else:
            raise ValueError("No max and/or min specified in "
                             "GalacticLatitudeConstraint.")
        return mask


class SunSeparationConstraint(Constraint):
    """
    Constrain the distance between the Sun and some targets.
    """

    def __init__(self, min=None, max=None):
        """
        Parameters
        ----------
        min : `~astropy.units.Quantity` or `None` (optional)
            Minimum acceptable separation between Sun and target (inclusive).
            `None` indicates no limit.
        max : `~astropy.units.Quantity` or `None` (optional)
            Maximum acceptable separation between Sun and target (inclusive).
            `None` indicates no limit.
        """
        self.min = min

mask = np.array([min_time <= t.time() <= max_time for t in times.datetime])
            except BaseException:                # use np.bool so shape queries don't cause problems
                mask = np.bool_(min_time <= times.datetime.time() <= max_time)

        # If time boundaries straddle midnight:
        else:
            try:
                mask = np.array([(t.time() >= min_time) or
                                (t.time() <= max_time) for t in times.datetime])
            except BaseException:
                mask = np.bool_((times.datetime.time() >= min_time) or
                                (times.datetime.time() <= max_time))
        return mask


class TimeConstraint(Constraint):
    """Constrain the observing time to be within certain time limits.

    An example use case for this class would be to associate an acceptable
    time range with a specific observing block. This can be useful if not
    all observing blocks are valid over the time limits used in calls
    to `is_observable` or `is_always_observable`.
    """

    def __init__(self, min=None, max=None):
        """
        Parameters
        ----------
        min : `~astropy.time.Time`
            Earliest time (inclusive). `None` indicates no limit.

        max : `~astropy.time.Time`

moon_separation = moon.separation(targets)

        if self.min is None and self.max is not None:
            mask = self.max >= moon_separation
        elif self.max is None and self.min is not None:
            mask = self.min <= moon_separation
        elif self.min is not None and self.max is not None:
            mask = ((self.min <= moon_separation) &
                    (moon_separation <= self.max))
        else:
            raise ValueError("No max and/or min specified in "
                             "MoonSeparationConstraint.")
        return mask


class MoonIlluminationConstraint(Constraint):
    """
    Constrain the fractional illumination of the Earth's moon.

    Constraint is also satisfied if the Moon has set.
    """

    def __init__(self, min=None, max=None, ephemeris=None):
        """
        Parameters
        ----------
        min : float or `None` (optional)
            Minimum acceptable fractional illumination (inclusive). `None`
            indicates no limit.
        max : float or `None` (optional)
            Maximum acceptable fractional illumination (inclusive). `None`
            indicates no limit.

observer : `~astroplan.Observer`
            the observaton location from which to apply the constraints
        targets : sequence of `~astroplan.Target`
            The targets on which to apply the constraints.

        Returns
        -------
        constraint_result : 2D array of float or bool
            The constraints, with targets along the first index and times along
            the second.
        """
        # Should be implemented on each subclass of Constraint
        raise NotImplementedError


class AltitudeConstraint(Constraint):
    """
    Constrain the altitude of the target.

    .. note::
        This can misbehave if you try to constrain negative altitudes, as
        the `~astropy.coordinates.AltAz` frame tends to mishandle negative


    Parameters
    ----------
    min : `~astropy.units.Quantity` or `None`
        Minimum altitude of the target (inclusive). `None` indicates no limit.
    max : `~astropy.units.Quantity` or `None`
        Maximum altitude of the target (inclusive). `None` indicates no limit.
    boolean_constraint : bool
        If True, the constraint is treated as a boolean (True for within the