a dictionary of ranges

[Windspar]

Here a start.
float_range.py . Some small changes

from fractions import Fraction

class FloatRange:
    # width = how many float points
    def __init__(self, width, start, end, step=1):
        self.base = width, start, end, step
        self.width = Fraction(10 ** width, 1)
        if end is None:
            self.end = self.num_to_fraction(start)
            self.start = Fraction(1, 10 ** width)
        else:
            self.start = self.num_to_fraction(start)
            self.end = self.num_to_fraction(end)

        self.step = Fraction(step, 10 ** width)
        self.float_range = self.start, self.end, self.step

    def num_to_fraction(self, pynum):
        if type(pynum) is float:
            f = str(pynum)
            i = f.find('.') + 1
            return Fraction(int(f.replace('.', '')), 10 ** (len(f) - i))
        return Fraction(pynum, 1)

    def convert(self, value):
        str_value = str(value)
        index = str_value.find('.') + 1
        width = len(str_value) - index
        if width < self.base[0]:
            return int(str_value.replace('.','')) * (10 ** (self.base[0] - width))
        elif index == 0:
            return int(str_value.replace('.','')) * (10 ** self.base[0])
        return int(str_value.replace('.',''))

    def __iter__(self):
        self.start = self.float_range[0]
        while self.start < self.end:
            yield float(self.start)
            self.start += self.step

    def __lt__(self, value):
        return self.num_to_fraction(value) > self.float_range[1]

    def __gt__(self, value):
        return self.num_to_fraction(value) < self.float_range[0]

    def with_in(self, value):
        s, e, st = self.float_range
        if type(value) is FloatRange:
            s2, e2, st2 = value.float_range
            if self.with_in(s2) or self.with_in(e2) or value.with_in(s) or value.with_in(e):
                return True
            return False
        else:
            v = self.num_to_fraction(value)
            return  s <= v < e

    def __contains__(self, value):
        v = self.convert(value)
        s = int(self.float_range[0] * self.width)
        e = int(self.float_range[1] * self.width)
        st = int(self.float_range[2] * self.width)
        return v in range(s, e, st)

    def __repr__(self):
        line = "FloatRange: {0}Width: {1}, Start: {2}, End: {3}, Step: {4}{5}"
        return line.format('{', *self.base, '}')

if __name__ == "__main__":
    for i in range(1,4):
        frange = FloatRange(i, 4.5, 4.7)
        print("\n ** FloatRange contains float point", i, "**")
        print(452 in frange)
        print(45.2 in frange)
        print(4.52 in frange)
        print(4.521 in frange)

    print("\n ** Less than and Greater than test **")
    frange = FloatRange(2, 4.5, 4.7)
    print(4.4 < frange)
    print(4.6 < frange)
    print(4.6 > frange)
    print(4.8 > frange)

    print("\n ** Within test **")
    a = FloatRange(1, 4.6, 5.0)
    b = FloatRange(3, 4.6, 5.0)
    c = FloatRange(2, 4.0, 5.0)
    d = FloatRange(2, 4.9, 5.0)
    print(a.with_in(frange))
    print(b.with_in(frange))
    print(c.with_in(frange))
    print(d.with_in(frange))

    print("\n ** Output test **")
    for i in frange:
        print(i)

ranges.py

from float_range import FloatRange

class Ranges:
    def __init__(self):
        self.ranges = {}

    def items(self):
        return self.ranges.items()

    def keys(self):
        return self.ranges.keys()

    def values(self):
        return self.ranges.values()

    def __getitem__(self, key):
        return self.ranges[key]

    def __delitem__(self, key):
        del self.ranges[key]

    def add(self, key_name, width, start, end=None, step=1):
        if end is None:
            self.ranges[key_name] = FloatRange(width, start)
        else:
            self.ranges[key_name] = FloatRange(width, start, end, step)

    def fetch(self, value, value_end=None):
        return_keys = []
        if value_end is None:
            for key, f_range in self.items():
                if value in f_range:
                    return_keys.append(key)
        else:
            v_range = FloatRange(0, value, value_end)
            for key, f_range in self.items():
                if f_range.with_in(v_range):
                    return_keys.append(key)

        return return_keys

    def smash(self, start, end=None):
        del_keys = []
        if end is None:
            for key, f_range in self.items():
                if start in f_range: # or with_in
                    del_keys.append(key)
        else:
            v_range = FloatRange(0, start, end)
            for key, f_range in self.items():
                if v_range.with_in(f_range):
                    del_keys.append(key)

        for key in del_keys:
            del self.ranges[key]

    def merge(self, key1, key2):
        return FloatRange(
            max(self.ranges[key1].base[0], self.ranges[key2].base[0]),
            min(self.ranges[key1].base[1], self.ranges[key2].base[1]),
            max(self.ranges[key1].base[2], self.ranges[key2].base[2]),
            min(self.ranges[key1].base[3], self.ranges[key2].base[3]) )


if __name__ == '__main__':
    m_range = Ranges()
    m_range.add('foo', 1, 2, 3.5)
    m_range.add('bar', 1, 4.5, 6)
    m_range.add('foo2', 1, 7.5, 10)
    for i in m_range['foo']:
        print(i)

    print(m_range.keys())

    print("\n ** Merge Test **")
    print(m_range.merge('foo', 'bar'))

    print("\n ** Smash Test **")
    m_range.smash(3, 5)
    print(m_range.keys())

    print("\n ** Fetch Test **")
    m_range.add('foo', 1, 2, 3.5)
    m_range.add('bar', 1, 4.5, 6)
    print(m_range.fetch(3, 5))