Intervals

Common errors

• TypeError: 'Interval' object is not iterable

  cause Attempting to directly iterate over an `Interval` object as if it were a sequence of numbers (e.g., `for x in my_interval:`). The `Interval` object represents a range, not a collection of discrete values for iteration.
  fix If you need to iterate over discrete values within an interval, you must explicitly generate them (e.g., using `range()` for integer intervals) or convert the interval to a list of its atomic components if it's an `IntervalSet` (though this library's `Interval` class is not a set of points). For `portion` (a recommended alternative), you can use `P.open(1, 5).iterate(int)`.

• ValueError: Invalid interval: upper bound must be greater than or equal to lower bound if both bounds are open.

  cause This error occurs when trying to create an interval like `(5, 5)`, where both bounds are open and equal, which implies an empty interval that cannot contain any number, and is considered an invalid construction by this library.
  fix To represent an empty interval with equal bounds, ensure at least one bound is closed, e.g., `Interval.closedopen(5, 5)` or `Interval.openclosed(5, 5)` will correctly yield an empty interval. For a singleton, use `Interval.closed(5, 5)`.

• AttributeError: 'Interval' object has no attribute 'overlaps'

  cause This specific error indicates that the `intervals` library (kvesteri's) in version 0.9.x might not provide a direct `overlaps` method on the `Interval` object itself, unlike some other interval libraries (e.g., `portion` or `pyinterval`). Users often expect such methods based on experience with other libraries or common interval logic.
  fix To check for overlap with this library, you would typically need to implement the logic manually by comparing the bounds of the two intervals (e.g., `max(interval1.lower, interval2.lower) < min(interval1.upper, interval2.upper)` considering open/closed bounds). Alternatively, consider migrating to a more feature-rich library like `portion` which provides a dedicated `overlaps()` method.

Warnings

• breaking This library (`intervals` by kvesteri, version 0.9.2) is unmaintained and has not seen updates since 2016. It is highly recommended to use a currently maintained alternative, such as `portion` (which is a successor to a related library `python-intervals`), `pyinterval`, or `intervaltree` for better support, features, and Python version compatibility.
  Fix: Migrate to `portion` (pip install portion) or `intervaltree` (pip install intervaltree).
• gotcha Attempting to create a fully open, degenerate interval (e.g., `(a..a)`) will result in a `ValueError`. Both endpoints may be equal only if at least one of the bounds is closed (e.g., `[a..a]`, `[a..a)`, `(a..a]`).
  Fix: Ensure that if the lower and upper bounds are identical, at least one of the interval's boundaries is closed. For example, use `Interval.closed(a, a)` for a singleton or `Interval.closedopen(a, a)` for an empty interval with one closed bound.
• gotcha The `Interval()` constructor acts as a factory, attempting to guess the best matching interval subtype (e.g., `IntInterval`, `DateInterval`) based on the provided bounds. While convenient, this auto-detection can sometimes be slower or lead to unexpected types. For performance and clarity, directly instantiating specific interval types (e.g., `IntInterval(1, 5)`) is recommended if the type is known.
  Fix: Explicitly import and use specialized interval classes like `IntInterval`, `FloatInterval`, `DateInterval`, `DateTimeInterval` when working with known data types, rather than relying solely on the generic `Interval()` factory.

Install

• pip install intervals Install latest 0.9.x version

Imports

• Interval
  wrong:

  import intervals.Interval

  correct:

  from intervals import Interval

  The primary interval class is directly importable from the top-level package.

Quickstart

Demonstrates how to create `Interval` objects using factory methods and directly, and how to perform a basic containment check. Note that rich interval operations (like `overlaps`, `intersection`, `union`) might be less intuitive or require manual implementation with this older, unmaintained library compared to modern alternatives.

from intervals import Interval, IntInterval

# Create an interval using the factory method
i1 = Interval.closed(1, 5) # Represents [1, 5]
print(f"Interval i1: {i1}")

# Create a half-open interval
i2 = Interval.closedopen(5, 10) # Represents [5, 10)
print(f"Interval i2: {i2}")

# Create a specific type of interval (e.g., integer interval)
i3 = IntInterval(3, 7) # Represents [3, 7]
print(f"Interval i3: {i3}")

# Check for containment
print(f"4 in i1: {4 in i1}") # Expected: True
print(f"5 in i2: {5 in i2}") # Expected: True
print(f"10 in i2: {10 in i2}") # Expected: False

# Check for overlap (note: older versions might not have a direct 'overlaps' method, requiring manual check or utility functions)
# For simple overlap, you might compare bounds manually or use set operations if applicable
# Or, rely on a library like 'portion' for richer operations.