def f(x):
    result = []
    for part in x.split(','):
        if '-' in part:
            a, b = part.split('-')
            a, b = int(a), int(b)
            result.extend(range(a, b + 1))
        else:
            a = int(part)
            result.append(a)
    return result

>>> f('1,2,5-7,10')
[1, 2, 5, 6, 7, 10]

Disclaimer: I'm not a Python programmer!

Your code isn't that bad. It's readable enough for me to understand it. B+ for readability!

Currently, you have this function:

def giveRange(numString:str):
    z=numString.split("-")
    if(len(z)==1):
        return [int(z[0])]
    elif(len(z)==2):
        return list(range(int(z[0]),int(z[1])+1))
    else:
        raise IndexError("TOO MANY VALS!")

Why don't you simply store the length in a variable?

Like this:

length=len(z)
if(length==1):
    return [int(z[0])]
elif(length==2):
    return list(range(int(z[0]),int(z[1])+1))
else:
    raise IndexError("TOO MANY VALS!")

Now, you don't have to calculate the length twice, only once.

The name z is a really bad name. Better names would be numbers, pieces or something similar.

Looking at the definition of chain(), it seems to accept any iterable, which a range() happens to be. So, you probably don't need that list(), leaving this:

return range(int(z[0]),int(z[1])+1)

On your function unpackNums instead of creating an empty set(), you could use the a set comprehension:

def unpackNums(numString:str):
    return {x for x in set(chain(*map(giveRange,numString.split(","))))}

If you notice any inaccuracies, please comment.

Use parseIntSet from here

I also like the pyparsing implementation in the comments at the end.

The parseIntSet has been modified here to handle "<3"-type entries and to only spit out the invalid strings if there are any.

#! /usr/local/bin/python
import sys
import os

# return a set of selected values when a string in the form:
# 1-4,6
# would return:
# 1,2,3,4,6
# as expected...

def parseIntSet(nputstr=""):
    selection = set()
    invalid = set()
    # tokens are comma seperated values
    tokens = [x.strip() for x in nputstr.split(',')]
    for i in tokens:
        if len(i) > 0:
            if i[:1] == "<":
                i = "1-%s"%(i[1:])
        try:
            # typically tokens are plain old integers
            selection.add(int(i))
        except:
            # if not, then it might be a range
            try:
                token = [int(k.strip()) for k in i.split('-')]
                if len(token) > 1:
                    token.sort()
                    # we have items seperated by a dash
                    # try to build a valid range
                    first = token[0]
                    last = token[len(token)-1]
                    for x in range(first, last+1):
                        selection.add(x)
            except:
                # not an int and not a range...
                invalid.add(i)
    # Report invalid tokens before returning valid selection
    if len(invalid) > 0:
        print "Invalid set: " + str(invalid)
    return selection
# end parseIntSet

print 'Generate a list of selected items!'
nputstr = raw_input('Enter a list of items: ')

selection = parseIntSet(nputstr)
print 'Your selection is: '
print str(selection)

And here's the output from the sample run:

$ python qq.py
Generate a list of selected items!
Enter a list of items: <3, 45, 46, 48-51, 77
Your selection is:
set([1, 2, 3, 45, 46, 77, 48, 49, 50, 51])

The daterangeparser library only supports specific string formatting.

Looking at the documentation, this is one way which is likely to work:

from datetime import datetime as dt
from daterangeparser import parse

c = '2018-03-10 - 2018-06-15'

test = ' - '.join([dt.strptime(i, '%Y-%m-%d').strftime('%d %b %Y') for i in c.split(' - ')])
# '10 Mar 2018 - 15 Jun 2018'    

res = parse(test)

However, for what you are looking to do it seems like you may not need to use daterangeparser.

For parsing HTML in Python, I prefer BeautifulSoup. This is assuming you want to find links, and not just the literal <a href=, which you can easily do searching through the string.