Exemple #1
0
 def _setupCategories(self, config):
     """Add buttons to browse between categories
     
     config -- ConfigParser containing application settings
     
     """
     #Get all button data
     lines = []
     ctr = 1
     option = ini.image + str(ctr)
     
     while(config.has_option(ini.year, option)):
         line = config.get(ini.year, option)
         lines.append(line)
         ctr += 1
         option = ini.image + str(ctr)
         
     #Create as many buttons as needed
     buttondata = zip(lines, self._years)
     
     if(len(buttondata) < len(self._years)):
         print('Warning! There are more categories than category buttons - some categories will not be shown')
         
     ctr = 0
     
     for (line, year) in buttondata:
         tb = TransparentButton(self._canvas, self._settings.generalfont, line, self._scalefactor)
         tb.setText(year)
         tb.setCommand(self._ehYear)
         tb.index = ctr
         ctr += 1
         self._activeInPreview.append(tb)
Exemple #2
0
 def test_tuple_reuse(self):
     if test_support.due_to_ironpython_incompatibility("implementation detail: http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=20279"): 
         return
     # Tests an implementation detail where tuple is reused
     # whenever nothing else holds a reference to it
     self.assertEqual(len(set(map(id, list(enumerate(self.seq))))), len(self.seq))
     self.assertEqual(len(set(map(id, enumerate(self.seq)))), min(1,len(self.seq)))
Exemple #3
0
    def test_len(self):
        if test_support.due_to_ironpython_incompatibility(
                "implementation detail"):
            return
        # This is an implementation detail, not an interface requirement
        from test.test_iterlen import len
        for s in ('hello', tuple('hello'), list('hello'), xrange(5)):
            self.assertEqual(len(reversed(s)), len(s))
            r = reversed(s)
            list(r)
            self.assertEqual(len(r), 0)

        class SeqWithWeirdLen:
            called = False

            def __len__(self):
                if not self.called:
                    self.called = True
                    return 10
                raise ZeroDivisionError

            def __getitem__(self, index):
                return index

        r = reversed(SeqWithWeirdLen())
        self.assertRaises(ZeroDivisionError, len, r)
Exemple #4
0
def compute_max_pile(numbers_ls):
    # from str to int
    numbers_ls = map(int, numbers_ls)
    
    # compute the "global xor" = xor of all elements
    global_xor = compute_group_xor(numbers_ls)
    
    # real sum of all elements
    global_sum = sum(numbers_ls)
    
    # all condition fitting groups
    relevant_groups = []
    
    # for each size < length(numbers_ls) check if any of that size piles 
    # fit our condition
    for k in range(1, len(numbers_ls)/2 + 1):
        for subset in k_subsets(numbers_ls, k):
            group_xor = compute_group_xor(subset)
            if  group_xor ^ global_xor == group_xor:
                relevant_groups.append(subset)
                 
    # find max of appropriate groups, if any group exists
    if len(relevant_groups) == 0:
        return None
    
    max_group = 0;
    for group in relevant_groups:
        group_sum = sum(group)
        group_sum = max([group_sum, global_sum - group_sum])
        if group_sum > max_group:
            max_group = group_sum
            
    return max_group
Exemple #5
0
    def sort(self, data):
        
        if data == None or len(data) < 1:
            return data 
        
        print data
                
        base_value = data[0]
        left_array = []
        right_array = []
        
        for index in range(1, len(data)):
            compare_value = data[index]
            if(base_value > compare_value):
                left_array.append(compare_value)
            else:
                right_array.append(compare_value) 
        
        if len(left_array) > 1:
            sorted_array = self.sort(left_array)
            left_array = sorted_array
            
        
        if len(right_array) > 1:
            sorted_array = self.sort(right_array)
            right_array = sorted_array

        right_array.insert(0, base_value)
        left_array.extend(right_array)
        
        return left_array
Exemple #6
0
 def test_tuple_reuse(self):
     # Tests an implementation detail where tuple is reused
     # whenever nothing else holds a reference to it
     self.assertEqual(len(set(map(id, list(enumerate(self.seq))))),
                      len(self.seq))
     self.assertEqual(len(set(map(id, enumerate(self.seq)))),
                      min(1, len(self.seq)))
Exemple #7
0
def getSkuMap(url):
    content = urllib2.urlopen(url)

    token = "None"
    brace_level = 0
    skuMap = []
    parseStock = False

    for line in content:
        gbk_line = line.decode('gbk')

        m1 = re.search('"skuMap":', gbk_line)
        if m1:
            token = "skuMap"
            brace_level = brace_level + 1
            continue
        if token == "skuMap":
            # print brace_level , " " , gbk_line
            if brace_level == 2:
                m1 = re.match('.*";(.*);".*', gbk_line)
                if m1:
                    #  We find a skumap
                    # add a map to it
                    skuMap.append({})
                    skuMap[len(skuMap) - 1]["index"] = m1.group(1)
                    # print len(skuMap) , " " , m1.group(1)

            if brace_level == 3:
                m1 = re.match('.*"skuId" : "([0-9]*)".*', gbk_line)
                if m1:
                    skuMap[len(skuMap) - 1]["skuId"] = m1.group(1)
                    continue
                m1 = re.match('.*"price" : "([0-9\.]*)".*', gbk_line)
                if m1:
                    skuMap[len(skuMap) - 1]["price"] = m1.group(1)
                    continue

                m1 = re.search('stock', gbk_line)
                if m1:
                    parseStock = True
                    continue

                if parseStock:
                    m1 = re.match('.*"([0-9]*)".*', gbk_line)
                    if m1:
                        skuMap[len(skuMap) - 1]["stock"] = m1.group(1)
                        parseStock = False

            if re.match(".*{.*", gbk_line):
                brace_level = brace_level + 1
            if re.match(".*}.*", gbk_line):
                brace_level = brace_level - 1
            if brace_level == 0:
                token = "None"

    return skuMap
Exemple #8
0
def getSkuMap(url):
    content = urllib2.urlopen(url)
    
    token = "None"
    brace_level = 0 
    skuMap = [] 
    parseStock = False
    
    for line in content : 
        gbk_line = line.decode('gbk')
               
        m1 = re.search('"skuMap":', gbk_line)
        if m1 :
            token = "skuMap"
            brace_level = brace_level + 1 
            continue       
        if token == "skuMap" :
            # print brace_level , " " , gbk_line
            if brace_level == 2 : 
                m1 = re.match('.*";(.*);".*', gbk_line)
                if m1 :
                    #  We find a skumap 
                    # add a map to it 
                    skuMap.append({})
                    skuMap[len(skuMap) - 1]["index"] = m1.group(1)
                    # print len(skuMap) , " " , m1.group(1)
            
            if brace_level == 3 : 
                m1 = re.match('.*"skuId" : "([0-9]*)".*', gbk_line)
                if m1 :
                    skuMap[len(skuMap) - 1]["skuId"] = m1.group(1)
                    continue
                m1 = re.match('.*"price" : "([0-9\.]*)".*', gbk_line)
                if m1 :
                    skuMap[len(skuMap) - 1]["price"] = m1.group(1)
                    continue
                
                m1 = re.search('stock', gbk_line)
                if m1 : 
                    parseStock = True 
                    continue 
                
                if parseStock : 
                    m1 = re.match('.*"([0-9]*)".*', gbk_line)
                    if m1 :
                        skuMap[len(skuMap) - 1]["stock"] = m1.group(1)
                        parseStock = False             
                    
            if re.match(".*{.*" , gbk_line) : 
                brace_level = brace_level + 1
            if re.match(".*}.*" , gbk_line) : 
                brace_level = brace_level - 1 
            if brace_level == 0 : 
                token = "None"
    
    return skuMap
Exemple #9
0
 def test_tuple_reuse(self):
     if test_support.due_to_ironpython_incompatibility(
             "implementation detail: http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=20279"
     ):
         return
     # Tests an implementation detail where tuple is reused
     # whenever nothing else holds a reference to it
     self.assertEqual(len(set(map(id, list(enumerate(self.seq))))),
                      len(self.seq))
     self.assertEqual(len(set(map(id, enumerate(self.seq)))),
                      min(1, len(self.seq)))
Exemple #10
0
def index(request):
    first_news = []
    first_news_list = SportNews.objects.filter(
        priority='NEWS_MAIN').order_by('-created_at')
    if len(first_news_list) > 0:
        news_info = {}
        news_info['title'] = first_news_list[0].title
        news_info['img'] = '/media/' + str(first_news_list[0].photo)
        first_news.append(first_news_list[0].id)
        first_news.append(news_info)
    main_news = []
    for news_prio in NEWS_PRIO:
        if news_prio[0] != 'NEWS_NORMAL' and news_prio[0] != 'NEWS_MAIN':
            main_news_list = SportNews.objects.filter(
                priority=news_prio[0]).order_by('-created_at')
            if len(main_news_list) > 0:
                news_info = {}
                news_info['title'] = main_news_list[0].title
                news_info['img'] = '/media/' + str(main_news_list[0].photo)
                news = []
                news.append(main_news_list[0].id)
                news.append(news_info)
                main_news.append(news)

    other_news_list = SportNews.objects.all().order_by('-created_at')[:20]
    other_news = []
    for other in other_news_list:
        news = []
        news.append(other.id)
        news.append(other.photo)
        news.append(other.title)
        isItemInMainNews = False
        for mainNewsItem in main_news:
            if mainNewsItem[0] == news[0]:
                isItemInMainNews = True
        if not isItemInMainNews and first_news and other.id != first_news[0]:
            other_news.append(news)

    return render(request,
                  'main/index.html', {
                      'user_info': getUseInfo(request),
                      'navigationBar': getNavigationBar(),
                      'side_bar': getSideBar(),
                      'first_news': first_news,
                      'main_news': main_news,
                      'other_news': other_news,
                  },
                  context_instance=RequestContext(request))
def getXMLNode(data):
    if len(data) < 5:
        print data
        return (2, "")
    eventDict = {}
    eventDict["date"] = strip(data[0])
    eventDict["text"] = strip(data[1])
    eventDict["img"] = strip(data[2])
    eventDict["vetName"] = strip(data[3])
    eventDict["vetID"] = strip(data[4])

    isVetNode = (
        eventDict["date"] == ""
        and eventDict["text"] == ""
        and eventDict["img"] == ""
        and not eventDict["vetName"] == ""
        and not eventDict["vetID"] == ""
    )
    isEmpty = not isVetNode and eventDict["img"] == ""
    isCusLink = isCustomLink(eventDict["img"])
    isBadVetID = isCustomLink(eventDict["vetID"])
    isEmptyName = eventDict["vetName"] == ""

    if isEmpty or isCusLink or isBadVetID or isEmptyName:
        return (3, eventDict)

    if isVetNode:
        return (1, getVetNode(eventDict))
    elif eventDict["date"] == "Date":
        return (2, "")
    else:
        return (0, getEventNode(eventDict))
Exemple #12
0
    def on_categoriesview_activated(self, index):
        articulo = self.categoriesview.model().asRecord(index)
        if len(articulo) > 0:
            nuevo = True

            for i, line in enumerate(self.editmodel.lines):
                if line.itemId == articulo[5]:
                    nuevo = False
                    fila = i
                    line = self.editmodel.lines[self.editmodel.rowCount() - 1]

            if nuevo:
                fila = self.editmodel.rowCount()
                self.editmodel.insertRow(fila)
                self.parent.saveAct.setEnabled(True)
                linea = self.editmodel.lines[fila]
                linea.itemDescription = articulo[0] + " " + articulo[1]
                linea.itemPrice = Decimal(articulo[2])
                linea.itemId = articulo[5]

                linea.quantityperbox = int(articulo[3])

            self.editmodel.lines[fila].quantity += 1
            self.editmodel.lines[fila].existencia = int(
                articulo[4]) - self.editmodel.lines[fila].quantity
            indice = self.editmodel.index(fila, 2)
            self.editmodel.dataChanged.emit(indice, indice)
            indice = self.editmodel.index(fila, 3)
            self.editmodel.dataChanged.emit(indice, indice)
            indice = self.editmodel.index(fila, 5)
            self.editmodel.dataChanged.emit(indice, indice)
Exemple #13
0
def remove_adjacent(nums):
  listx = []
  for num in nums:
    from test.test_iterlen import len
    if len(listx) == 0 or num != listx[-1]:
      listx.append(num)
  return listx
Exemple #14
0
 def on_categoriesview_activated(self,index):
     articulo = self.categoriesview.model().asRecord(index)
     if len(articulo)>0:
         nuevo = True
         
         for i, line in enumerate(self.editmodel.lines):
             if line.itemId == articulo [5]:
                 nuevo = False
                 fila = i
                 line = self.editmodel.lines[self.editmodel.rowCount()-1]
             
         if nuevo:       
             fila = self.editmodel.rowCount()
             self.editmodel.insertRow(fila)
             self.parent.saveAct.setEnabled(True)
             linea = self.editmodel.lines[fila]        
             linea.itemDescription = articulo[0] + " " + articulo [1]
             linea.itemPrice = Decimal(articulo[2])
             linea.itemId = articulo[5]
             
             linea.quantityperbox = int(articulo[3])
         
         
         self.editmodel.lines[fila].quantity += 1
         self.editmodel.lines[fila].existencia  = int(articulo[4]) - self.editmodel.lines[fila].quantity 
         indice =self.editmodel.index( fila,2)
         self.editmodel.dataChanged.emit( indice, indice )
         indice =self.editmodel.index( fila,3)
         self.editmodel.dataChanged.emit( indice, indice )
         indice =self.editmodel.index( fila,5)
         self.editmodel.dataChanged.emit( indice, indice )
Exemple #15
0
def verbing(s):
  from test.test_iterlen import len
  if len(s) < 3:
    return s
  if s[-3:] == "ing":
    return s + "ly"
  else:
    return s + "ing"
 def test_izip(self):
     ans = [(x, y) for x, y in izip("abc", count())]
     self.assertEqual(ans, [("a", 0), ("b", 1), ("c", 2)])
     self.assertEqual(list(izip("abc", range(6))), zip("abc", range(6)))
     self.assertEqual(list(izip("abcdef", range(3))), zip("abcdef", range(3)))
     self.assertEqual(take(3, izip("abcdef", count())), zip("abcdef", range(3)))
     self.assertEqual(list(izip("abcdef")), zip("abcdef"))
     self.assertEqual(list(izip()), zip())
     self.assertRaises(TypeError, izip, 3)
     self.assertRaises(TypeError, izip, range(3), 3)
     # Check tuple re-use (implementation detail)
     self.assertEqual([tuple(list(pair)) for pair in izip("abc", "def")], zip("abc", "def"))
     self.assertEqual([pair for pair in izip("abc", "def")], zip("abc", "def"))
     ids = map(id, izip("abc", "def"))
     self.assertEqual(min(ids), max(ids))
     ids = map(id, list(izip("abc", "def")))
     self.assertEqual(len(dict.fromkeys(ids)), len(ids))
    def battleToSinglePC(self, enemy, battleType = 1, timeLimit = 1800):
        timeLeft = timeLimit
        dataList = []
        infoFighter = []
        infoEnemy = [enemy.getCommonValues_delta().copy()]
        fighterWin = False
        for item in self.getMyTeamInfomation():
            if item['type'] == 1: #PlayerCharacter object
                player = PlayersManager().getPlayerByID(item['id'])
                if player is None:
                    player = PlayersManager().createPlayerByID(item['id'])
                data = player.battle.fightTo(enemy, battleType, timeLeft)
                dataList.append(data)
                timeLeft -= data['overTime']
                if data["winner"] != enemy.getBaseID():
                    fighterWin = True
                    break
                infoFighter.append(player.getCommonValues_delta().copy())
            elif item["type"] == 2:
                pass

        overTime = 0
        HPMPDelta = []
        result = []

        startTime = 0
        uL = dataList[-1]['battleEventProcessList'][-1]
        for i in dataList:
            i['battleEventProcessList'].pop(0)
            i['battleEventProcessList'].pop(-1)
            for e in i['battleEventProcessList']:
                e[0] += startTime
            for d in i["MPHPDelta"]:
                d["time"] += startTime
            result += i['battleEventProcessList']
            HPMPDelta += i["MPHPDelta"]
            startTime += i["overTime"]

        # create end event
        if fighterWin:
            battleResult_set = []
            result_i = [] #{}
            for i in range(len(infoFighter)):
                battleResult_set.append({'id':infoFighter[i]['id'], 'battleResult':result_i[i]})

            event = [overTime, 2, -1, battleResult_set]

        import datetime
        result.insert(0, [0, 1, -1, [infoFighter, infoEnemy, str(datetime.datetime.now())]])
        data = {}
        data['battleType'] = battleType
        data['maxTime'] = timeLimit
        data['timeLimit'] = timeLimit
        data['battleEventProcessList'] = result
        data['MPHPDelta'] = HPMPDelta#记录每秒玩家双方hp/mp增量
        data['overTime'] = overTime
        return data
        return
Exemple #18
0
def checkIfPasswordIsValid(password):
    if len(password) < 10:
        return False
    elif not checkIfStringContainsDigit(password):
        return False
    elif not CheckIfStringContainsCapitalLetter(password):
        return False
    else:
        return True
def checkIfPasswordIsValid(password):
    if len(password) < 10:
        return False
    elif not checkIfStringContainsDigit(password):
        return False
    elif not CheckIfStringContainsCapitalLetter(password):
        return False
    else:
        return True
Exemple #20
0
 def test_izip(self):
     ans = [(x,y) for x, y in izip('abc',count())]
     self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
     self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
     self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
     self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3)))
     self.assertEqual(list(izip('abcdef')), zip('abcdef'))
     self.assertEqual(list(izip()), zip())
     self.assertRaises(TypeError, izip, 3)
     self.assertRaises(TypeError, izip, range(3), 3)
     # Check tuple re-use (implementation detail)
     self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')],
                      zip('abc', 'def'))
     self.assertEqual([pair for pair in izip('abc', 'def')],
                      zip('abc', 'def'))
     ids = map(id, izip('abc', 'def'))
     self.assertEqual(min(ids), max(ids))
     ids = map(id, list(izip('abc', 'def')))
     self.assertEqual(len(dict.fromkeys(ids)), len(ids))
Exemple #21
0
 def test_cycle(self):
     for s in ("123", "", range(1000), ('do', 1.2), xrange(2000, 2200, 5)):
         for g in (G, I, Ig, S, L, R):
             tgtlen = len(s) * 3
             expected = list(g(s)) * 3
             actual = list(islice(cycle(g(s)), tgtlen))
             self.assertEqual(actual, expected)
         self.assertRaises(TypeError, cycle, X(s))
         self.assertRaises(TypeError, list, cycle(N(s)))
         self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
def test_main(verbose=None):
    support.run_unittest(__name__)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in range(len(counts)):
            support.run_unittest(__name__)
            counts[i] = sys.gettotalrefcount()
        print(counts)
Exemple #23
0
 def test_cycle(self):
     for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
         for g in (G, I, Ig, S, L, R):
             tgtlen = len(s) * 3
             expected = list(g(s))*3
             actual = list(islice(cycle(g(s)), tgtlen))
             self.assertEqual(actual, expected)
         self.assertRaises(TypeError, cycle, X(s))
         self.assertRaises(TypeError, list, cycle(N(s)))
         self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
Exemple #24
0
def k_subsets(s, k):
    '''
    Yield all subsets of size k from set (or list) s
    s -- a set or list (any iterable will suffice)
    k -- an integer > 0
    '''
    s = list(s)
    n = len(s)
    for k_set in k_subsets_i(n, k):
        yield set([s[i] for i in k_set])
Exemple #25
0
def test_main(verbose=None):
    test_support.run_unittest(__name__)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(__name__)
            counts[i] = sys.gettotalrefcount()
        print counts
 def test_len(self):
     # This is an implementation detail, not an interface requirement
     from test.test_iterlen import len
     for s in ('hello', tuple('hello'), list('hello'), range(5)):
         self.assertEqual(len(reversed(s)), len(s))
         r = reversed(s)
         list(r)
         self.assertEqual(len(r), 0)
     class SeqWithWeirdLen:
         called = False
         def __len__(self):
             if not self.called:
                 self.called = True
                 return 10
             raise ZeroDivisionError
         def __getitem__(self, index):
             return index
     r = reversed(SeqWithWeirdLen())
     self.assertRaises(ZeroDivisionError, len, r)
Exemple #27
0
    def test_izip(self):
        ans = [(x,y) for x, y in izip('abc',count())]
        self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
        self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
        self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
        self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3)))
        self.assertEqual(list(izip('abcdef')), zip('abcdef'))
        self.assertEqual(list(izip()), zip())
        self.assertRaises(TypeError, izip, 3)
        self.assertRaises(TypeError, izip, range(3), 3)
        # Check tuple re-use (implementation detail)
        self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')],
                         zip('abc', 'def'))
        self.assertEqual([pair for pair in izip('abc', 'def')],
                         zip('abc', 'def'))
        # Does not apply to Jython - no tuple reuse
#         ids = map(id, izip('abc', 'def'))
#         self.assertEqual(min(ids), max(ids))
        ids = map(id, list(izip('abc', 'def')))
        self.assertEqual(len(dict.fromkeys(ids)), len(ids))
Exemple #28
0
def create_node(parent, tag, content='',):
	'''
	创建一个新节点
	@param parent:父节点 
	@param tag:子节点标签
	@param content:节点闭合标签里的文本内容
	'''
	element = SubElement(parent, tag)
	if len(content) != 0:
		element.text = unicode(content , "gbk") #unicode转换
	return element
Exemple #29
0
 def test_izip(self):
     ans = [(x,y) for x, y in izip('abc',count())]
     self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
     self.assertEqual(list(izip('abc', range(6))), zip('abc', range(6)))
     self.assertEqual(list(izip('abcdef', range(3))), zip('abcdef', range(3)))
     self.assertEqual(take(3,izip('abcdef', count())), zip('abcdef', range(3)))
     self.assertEqual(list(izip('abcdef')), zip('abcdef'))
     self.assertEqual(list(izip()), zip())
     self.assertRaises(TypeError, izip, 3)
     self.assertRaises(TypeError, izip, range(3), 3)
     # Check tuple re-use (implementation detail)
     self.assertEqual([tuple(list(pair)) for pair in izip('abc', 'def')],
                      zip('abc', 'def'))
     self.assertEqual([pair for pair in izip('abc', 'def')],
                      zip('abc', 'def'))
     if test_support.check_impl_detail():
         # izip "reuses" the same tuple object each time when it can
         ids = map(id, izip('abc', 'def'))
         self.assertEqual(min(ids), max(ids))
     ids = map(id, list(izip('abc', 'def')))
     self.assertEqual(len(dict.fromkeys(ids)), len(ids))
Exemple #30
0
def create_node_attrib(parent, tag, attrib, content=''):
	'''
	创建一个新节点,带有属性
	@param parent:父节点 
	@param tag:子节点标签
	@param attrib:属性及属性值 z.B={'NUM':'123'}
	@param content:节点闭合标签里的文本内容
	'''
	element = SubElement(parent, tag, attrib)
	if len(content) != 0:
		element.text = unicode(content , "gbk") #unicode转换
	return element
def index(request):
    first_news = []
    first_news_list = SportNews.objects.filter(priority='NEWS_MAIN').order_by('-created_at')
    if len(first_news_list) > 0:
        news_info = {}
        news_info['title'] = first_news_list[0].title
        news_info['img'] = '/media/' + str(first_news_list[0].photo)
        first_news.append(first_news_list[0].id)
        first_news.append(news_info)
    main_news = []
    for news_prio in NEWS_PRIO:
        if news_prio[0] != 'NEWS_NORMAL' and news_prio[0] != 'NEWS_MAIN':
            main_news_list = SportNews.objects.filter(priority=news_prio[0]).order_by('-created_at')
            if len(main_news_list) > 0:
                news_info = {}
                news_info['title'] = main_news_list[0].title
                news_info['img'] = '/media/' + str(main_news_list[0].photo)
                news = []
                news.append(main_news_list[0].id)
                news.append(news_info)
                main_news.append(news)
    
    other_news_list = SportNews.objects.all().order_by('-created_at')[:20]
    other_news = []
    for other in other_news_list:
        news = []
        news.append(other.id)
        news.append(other.photo)
        news.append(other.title)
        isItemInMainNews = False
        for mainNewsItem in main_news:
            if mainNewsItem[0] == news[0]:
                isItemInMainNews = True
        if not isItemInMainNews and first_news and other.id != first_news[0]:
            other_news.append(news)
            
    return render(request,
                  'main/index.html', {'user_info': getUseInfo(request), 'navigationBar': getNavigationBar(),'side_bar': getSideBar(), 'first_news': first_news, 'main_news': main_news, 'other_news': other_news,},
                  context_instance=RequestContext(request)
                  )
Exemple #32
0
def test_main(verbose=None):
    testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig, TestReversed)
    test_support.run_unittest(*testclasses)

    # verify reference counting
    import sys

    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*testclasses)
            counts[i] = sys.gettotalrefcount()
        print counts
Exemple #33
0
def test_main(verbose=None):
    testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig,
                   TestReversed)
    test_support.run_unittest(*testclasses)

    # verify reference counting
    import sys
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*testclasses)
            counts[i] = sys.gettotalrefcount()
        print counts
Exemple #34
0
 def mutatingtuple(tuple1, f, tuple2):
     # this builds a tuple t which is a copy of tuple1,
     # then calls f(t), then mutates t to be equal to tuple2
     # (needs len(tuple1) == len(tuple2)).
     def g(value, first=[1]):
         if first:
             del first[:]
             f(z.next())
         return value
     items = list(tuple2)
     items[1:1] = list(tuple1)
     gen = imap(g, items)
     z = izip(*[gen]*len(tuple1))
     z.next()
Exemple #35
0
def loadImages(dirName):
    from os import listdir
    hwLabels = []
    trainingFileList = listdir(dirName)
    m = len(trainingFileList)
    trainingMat = zeros((m,1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0]
        classNumStr =  int(fileStr.split('_')[0])
        if classNumStr == 9:hwLabels.append(-1)
        else:hwLabels.append(1)
        trainingMat[i,:] = img2vector('%s/%s' % (dirName,fileNameStr))
    return trainingMat,hwLabels
Exemple #36
0
 def mutatingtuple(tuple1, f, tuple2):
     # this builds a tuple t which is a copy of tuple1,
     # then calls f(t), then mutates t to be equal to tuple2
     # (needs len(tuple1) == len(tuple2)).
     def g(value, first=[1]):
         if first:
             del first[:]
             f(z.next())
         return value
     items = list(tuple2)
     items[1:1] = list(tuple1)
     gen = imap(g, items)
     z = izip(*[gen]*len(tuple1))
     z.next()
Exemple #37
0
def divide(numerator, denominator, detect_repetition=True, digit_limit=None):

    # If repetition detection is off, you must 
    # specify a limit on the digits returned 
    if not detect_repetition and digit_limit == None:
        return None

    decimal_found = False
    
    # prime the loop
    v = numerator // denominator
    numerator = 10 * (numerator - v * denominator)
    answer = str(v)
    
    if numerator == 0:
        return answer
    
    answer += '.'
    
    # Maintain a list of all the intermediate numerators 
    # and the length of the output at the point where that 
    # numerator was encountered. If you encounter the same 
    # numerator again, then the decimal repeats itself from 
    # the last index that numerator was encountered at. 
    states = {}
    
    while numerator > 0 and (digit_limit == None or digit_limit > 0):
        # print numerator
        if detect_repetition:
            
            prev_state = states.get(numerator, None)
            if prev_state != None:
                start_repeat_index = prev_state
                non_repeating = answer[:start_repeat_index]
                repeating = answer[start_repeat_index:]
                return non_repeating + '[' + repeating + ']'
            
            states[numerator] = len(answer)
        
        v = numerator // denominator  # floor division. This gets the next digit in the decimal portion
        answer += str(v)  # concatenate next digit to answer
        numerator -= v * denominator  # next two lines do magic
        numerator *= 10
        if digit_limit != None:
            digit_limit -= 1
    
    if numerator > 0:
        return answer + '...'
    return answer
Exemple #38
0
    def readFile(self, filename, verbose):
        try:
            if verbose: print "started reading file: {}".format(filename)
            reader = open(filename,'r')
            if verbose: print "file in memory, loading lines into list"
#             a = 1
            for line in reader:
#                 if a > 100000: break
                line = line[1:]
                self.infile.append(line)
#                 a+=1
            self.numEntries = len(self.infile)
            if verbose: print "lines read"
            reader.close()
        except IOError:
            sys.exit('Cannot open input file: {}'.format(filename))
Exemple #39
0
def chooseShoppingItem(shoppingItems) :
    valuelist = [] 
    for key in shoppingItems.keys() : 
        print "Choose : " , key 
        for index , title in enumerate(shoppingItems[key].keys()):
            print index , " : " , title 
            
        # make sure a valid choice 
        index = inputValidNumber("Input the index : " , 0 , len(shoppingItems[key].keys()))  
        # get the title 
        if index != -1 :
            title = shoppingItems[key].keys()[index]
            print "You choose " , title 
            valuelist.append(shoppingItems[key][title])
    
    return valuelist 
Exemple #40
0
def selectJ(i,oS,Ei):
    maxK = -1;maxDeltaE = 0;Ej = 0
    oS.eCache[i] = [1,Ei]
    validEcacheList = nonzero(oS.eCache[:,0].A)[0]
    if(len(validEcacheList)) > 1:
        for k in validEcacheList:
            if k == i:continue
            Ek = calcEk(oS, k)
            deltaE = abs(Ei - Ek)
            if(deltaE > maxDeltaE):
                maxK = k;maxDeltaE = deltaE;Ej = Ek
        return maxK,Ej
    else:
        j = selectJrand(i, oS.m)
        Ej = calcEk(oS, j)
    return j,Ej
Exemple #41
0
def test_main(verbose=None):
    if support.is_jython:
        # XXX: CPython implementation details
        del EnumerateTestCase.test_tuple_reuse
        del TestReversed.test_len
    testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig,
                   TestReversed)
    support.run_unittest(*testclasses)

    # verify reference counting
    import sys
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in range(len(counts)):
            support.run_unittest(*testclasses)
            counts[i] = sys.gettotalrefcount()
        print(counts)
def test_main(verbose=None):
    if support.is_jython:
        # XXX: CPython implementation details
        del EnumerateTestCase.test_tuple_reuse
        del TestReversed.test_len
    testclasses = (EnumerateTestCase, SubclassTestCase, TestEmpty, TestBig,
                   TestReversed)
    support.run_unittest(*testclasses)

    # verify reference counting
    import sys
    if verbose and hasattr(sys, "gettotalrefcount"):
        counts = [None] * 5
        for i in range(len(counts)):
            support.run_unittest(*testclasses)
            counts[i] = sys.gettotalrefcount()
        print(counts)
Exemple #43
0
def test_main(verbose=None):
    test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
                    RegressionTests, LengthTransparency)
    test_support.run_unittest(*test_classes)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        import gc
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*test_classes)
            gc.collect()
            counts[i] = sys.gettotalrefcount()
        print counts

    # doctest the examples in the library reference
    test_support.run_doctest(sys.modules[__name__], verbose)
Exemple #44
0
def test_main(verbose=None):
    test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
                    RegressionTests, LengthTransparency)
    test_support.run_unittest(*test_classes)

    # verify reference counting
    if verbose and hasattr(sys, "gettotalrefcount"):
        import gc
        counts = [None] * 5
        for i in xrange(len(counts)):
            test_support.run_unittest(*test_classes)
            gc.collect()
            counts[i] = sys.gettotalrefcount()
        print counts

    # doctest the examples in the library reference
    test_support.run_doctest(sys.modules[__name__], verbose)
Exemple #45
0
def chooseShoppingItem(shoppingItems):
    valuelist = []
    for key in shoppingItems.keys():
        print "Choose : ", key
        for index, title in enumerate(shoppingItems[key].keys()):
            print index, " : ", title

        # make sure a valid choice
        index = inputValidNumber("Input the index : ", 0,
                                 len(shoppingItems[key].keys()))
        # get the title
        if index != -1:
            title = shoppingItems[key].keys()[index]
            print "You choose ", title
            valuelist.append(shoppingItems[key][title])

    return valuelist
Exemple #46
0
def compute_final_element_list(case_line):
    case_line_arr = case_line.split()

    # create combinations list
    num_of_combs = int(case_line_arr[0])
    combs_list = case_line_arr[1:num_of_combs + 1]
    combs_dict = {}

    for comb in combs_list:
        combs_dict[comb[:2]] = comb[2]
        combs_dict[comb[1] + comb[0]] = comb[2]

    # create oppositions list
    num_of_oppos = int(case_line_arr[num_of_combs + 1])
    first_opp_index = num_of_combs + 2
    oppos_list = case_line_arr[first_opp_index:first_opp_index + num_of_oppos]
    oppos_list = oppos_list + [opp[1] + opp[0] for opp in oppos_list]

    # create element list
    #    num_of_elements = int(case_line_arr[first_opp_index + num_of_oppos])
    elements_str = case_line_arr[first_opp_index + num_of_oppos + 1]
    elements_list = []
    last_elem_index = -1

    for elem in elements_str:
        if last_elem_index >= 0:
            cur_comb = elements_list[last_elem_index] + elem
            if combs_dict.has_key(cur_comb):
                elements_list[last_elem_index] = combs_dict[cur_comb]
            else:
                for elem_in_list in elements_list:
                    if elem + elem_in_list in oppos_list:
                        elements_list = []
                        last_elem_index = -1
                        break
                if len(elements_list) == 0:
                    continue
                else:
                    elements_list.append(elem)
                    last_elem_index += 1
        else:
            elements_list.append(elem)
            last_elem_index += 1

    return elements_list
 def updateLabels(self,index):
     articulo = self.categoriesview.model().asRecord(index)
     if len(articulo)>0:
         self.txtcategoria.setText( articulo[0])
         self.txtmarca.setText( articulo[1])
         
         self.articuloId = articulo[4]
         
         self.precioanterior = Decimal(articulo[2]) 
         self.unidadesanterior = int(articulo[3])
         
         if not self.ckprecio.isChecked(): 
             self.precio = Decimal(articulo[2])
             self.txtprecio.setValue(self.precio)
         
         if not self.ckunit.isChecked():
             self.unidades = int(articulo[3])
             self.txtunidades.setValue(self.unidades)
Exemple #48
0
def main():
    filepath = sys.argv[1]
    input_file = open(filepath, "rb")
    output_file = open(OUTPUT_FILEPATH, "wb")
    lines = input_file.readlines()[1:]
    input_file.close()

    for i, line in enumerate(lines):
        output_file.write("Case #%d: [" % (i + 1))
        final_elems_ls = compute_final_element_list(line)
        if len(final_elems_ls) > 0:
            for elem in final_elems_ls[:-1]:
                output_file.write("%s, " % (elem))
            output_file.write("%s]\n" % (final_elems_ls[-1]))
        else:
            output_file.write("]\n")

    output_file.close()
    return
Exemple #49
0
    def test_islice(self):
        for args in [          # islice(args) should agree with range(args)
                (10, 20, 3),
                (10, 3, 20),
                (10, 20),
                (10, 3),
                (20,)
                ]:
            self.assertEqual(list(islice(xrange(100), *args)), range(*args))

        for args, tgtargs in [  # Stop when seqn is exhausted
                ((10, 110, 3), ((10, 100, 3))),
                ((10, 110), ((10, 100))),
                ((110,), (100,))
                ]:
            self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))

        # Test stop=None
        self.assertEqual(list(islice(xrange(10), None)), range(10))
        self.assertEqual(list(islice(xrange(10), None, None)), range(10))
        self.assertEqual(list(islice(xrange(10), None, None, None)), range(10))
        self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
        self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))

        # Test number of items consumed     SF #1171417
        it = iter(range(10))
        self.assertEqual(list(islice(it, 3)), range(3))
        self.assertEqual(list(it), range(3, 10))

        # Test invalid arguments
        self.assertRaises(TypeError, islice, xrange(10))
        self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
        self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
        self.assertRaises(ValueError, islice, xrange(10), 'a')
        self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
        self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
        self.assertEqual(len(list(islice(count(), 1, 10, sys.maxint))), 1)
Exemple #50
0
    def test_islice(self):
        for args in [          # islice(args) should agree with range(args)
                (10, 20, 3),
                (10, 3, 20),
                (10, 20),
                (10, 3),
                (20,)
                ]:
            self.assertEqual(list(islice(xrange(100), *args)), range(*args))

        for args, tgtargs in [  # Stop when seqn is exhausted
                ((10, 110, 3), ((10, 100, 3))),
                ((10, 110), ((10, 100))),
                ((110,), (100,))
                ]:
            self.assertEqual(list(islice(xrange(100), *args)), range(*tgtargs))

        # Test stop=None
        self.assertEqual(list(islice(xrange(10), None)), range(10))
        self.assertEqual(list(islice(xrange(10), None, None)), range(10))
        self.assertEqual(list(islice(xrange(10), None, None, None)), range(10))
        self.assertEqual(list(islice(xrange(10), 2, None)), range(2, 10))
        self.assertEqual(list(islice(xrange(10), 1, None, 2)), range(1, 10, 2))

        # Test number of items consumed     SF #1171417
        it = iter(range(10))
        self.assertEqual(list(islice(it, 3)), range(3))
        self.assertEqual(list(it), range(3, 10))

        # Test invalid arguments
        self.assertRaises(TypeError, islice, xrange(10))
        self.assertRaises(TypeError, islice, xrange(10), 1, 2, 3, 4)
        self.assertRaises(ValueError, islice, xrange(10), -5, 10, 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, -5, -1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 10, -1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 10, 0)
        self.assertRaises(ValueError, islice, xrange(10), 'a')
        self.assertRaises(ValueError, islice, xrange(10), 'a', 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 'a')
        self.assertRaises(ValueError, islice, xrange(10), 'a', 1, 1)
        self.assertRaises(ValueError, islice, xrange(10), 1, 'a', 1)
        self.assertEqual(len(list(islice(count(), 1, 10, maxsize))), 1)
Exemple #51
0
def checkIfUserNameAlreadyExists(username):
    users = User.objects.filter(username=username)
    if len(users) > 0:
        return True
    else:
        return False
Exemple #52
0
        queriess = raw_input("whats the query??")
        requests = queriess.split(" ")
        newqueries = regexp_tokenize(queriess, pattern=r'\"(.*?)\"')
        queries = regexp_tokenize(re.sub(r'\".*?\"', "", queriess),
                                  pattern=r'\w+')
        '''splitting of query into tokens using regex_tokenization'''

        if requests[0] == 'similar':
            similar(requests[1])
            continue
        if requests[0] == 'df':
            req = ' '.join(requests[1:])
            reqs = regexp_tokenize(re.sub(r'\".*?\"', "", req), pattern=r'\w+')
            print reqs
            if len(reqs) == 1:
                ''' handling single word queries'''
                if reqs[0] not in index:
                    print 'Sorry, not found in any document!'
                else:
                    print 'number of documents it appears in is', len(
                        index[reqs[0]])
            requestset = set()
            if len(reqs) > 1:
                '''
                    handling only < single word requests
                    '''
                print reqs
                for r0 in reqs:
                    if r0 not in index:
                        continue
Exemple #53
0
    def test_groupby(self):
        # Check whether it accepts arguments correctly
        self.assertEqual([], list(groupby([])))
        self.assertEqual([], list(groupby([], key=id)))
        self.assertRaises(TypeError, list, groupby('abc', []))
        self.assertRaises(TypeError, groupby, None)
        self.assertRaises(TypeError, groupby, 'abc', lambda x: x, 10)

        # Check normal input
        s = [(0, 10, 20), (0, 11, 21), (0, 12, 21), (1, 13, 21), (1, 14, 22),
             (2, 15, 22), (3, 16, 23), (3, 17, 23)]
        dup = []
        for k, g in groupby(s, lambda r: r[0]):
            for elem in g:
                self.assertEqual(k, elem[0])
                dup.append(elem)
        self.assertEqual(s, dup)

        # Check nested case
        dup = []
        for k, g in groupby(s, lambda r: r[0]):
            for ik, ig in groupby(g, lambda r: r[2]):
                for elem in ig:
                    self.assertEqual(k, elem[0])
                    self.assertEqual(ik, elem[2])
                    dup.append(elem)
        self.assertEqual(s, dup)

        # Check case where inner iterator is not used
        keys = [k for k, g in groupby(s, lambda r: r[0])]
        expectedkeys = set([r[0] for r in s])
        self.assertEqual(set(keys), expectedkeys)
        self.assertEqual(len(keys), len(expectedkeys))

        # Exercise pipes and filters style
        s = 'abracadabra'
        # sort s | uniq
        r = [k for k, g in groupby(sorted(s))]
        self.assertEqual(r, ['a', 'b', 'c', 'd', 'r'])
        # sort s | uniq -d
        r = [k for k, g in groupby(sorted(s)) if list(islice(g, 1, 2))]
        self.assertEqual(r, ['a', 'b', 'r'])
        # sort s | uniq -c
        r = [(len(list(g)), k) for k, g in groupby(sorted(s))]
        self.assertEqual(r, [(5, 'a'), (2, 'b'), (1, 'c'), (1, 'd'), (2, 'r')])
        # sort s | uniq -c | sort -rn | head -3
        r = sorted([(len(list(g)), k) for k, g in groupby(sorted(s))],
                   reverse=True)[:3]
        self.assertEqual(r, [(5, 'a'), (2, 'r'), (2, 'b')])

        # iter.next failure
        class ExpectedError(Exception):
            pass

        def delayed_raise(n=0):
            for i in range(n):
                yield 'yo'
            raise ExpectedError

        def gulp(iterable, keyp=None, func=list):
            return [func(g) for k, g in groupby(iterable, keyp)]

        # iter.next failure on outer object
        self.assertRaises(ExpectedError, gulp, delayed_raise(0))
        # iter.next failure on inner object
        self.assertRaises(ExpectedError, gulp, delayed_raise(1))

        # __cmp__ failure
        class DummyCmp:
            def __cmp__(self, dst):
                raise ExpectedError

        s = [DummyCmp(), DummyCmp(), None]

        # __cmp__ failure on outer object
        self.assertRaises(ExpectedError, gulp, s, func=id)
        # __cmp__ failure on inner object
        self.assertRaises(ExpectedError, gulp, s)

        # keyfunc failure
        def keyfunc(obj):
            if keyfunc.skip > 0:
                keyfunc.skip -= 1
                return obj
            else:
                raise ExpectedError

        # keyfunc failure on outer object
        keyfunc.skip = 0
        self.assertRaises(ExpectedError, gulp, [None], keyfunc)
        keyfunc.skip = 1
        self.assertRaises(ExpectedError, gulp, [None, None], keyfunc)
Exemple #54
0
# Gets output Folder
driver = webdriver.Firefox()
main_window = driver.current_window_handle
counter = 0
data = open(outputPath + "source" + str(counter) + qr_code + ".txt", 'w')

for file in os.listdir(inputPath):
    if file.endswith(".html"):
        driver.find_element_by_css_selector('body').send_keys(Keys.CONTROL +
                                                              't')
        print "Parsing through: " + file
        driver.get("file:///" + inputPath + file)

        # Reads main data
        if len(driver.find_elements_by_css_selector('center')) != 0:
            main_data = driver.find_element_by_css_selector('center').text
        else:
            print "Could not find main_data for " + file
            continue

        if len(driver.find_elements_by_tag_name("b")) != 0:
            case_number = driver.find_elements_by_tag_name("b")[0].text
        else:
            print "Could not find case_number for " + file
            continue

        if len(main_data.split(case_number)) >= 2:
            if len(main_data.split(case_number)[1].split(
                    case_type_string)) != 0:
                name = main_data.split(case_number)[1].split(
Exemple #55
0
 def test_repeat(self):
     from test.test_iterlen import len
     self.assertEqual(len(repeat(None, 50)), 50)
     self.assertRaises(TypeError, len, repeat(None))
 query=json.loads(q.full_stat().replace(": ", ":").replace("'", '"').replace("\xa7", "§"))
 lowercasePlayers =  [x.lower() for x in query['players']]
 try:
     tree = ET.parse(file)
 except:
     tree = ET.Element('logfile')
 root = tree.getroot()
 logentry = ET.SubElement ( root, 'logentry' )
 datetime = ET.SubElement( logentry, 'datetime')
 datetime.text = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 players = ET.SubElement( logentry, 'datetime')
 players.text = query['numplayers']
 
 count =  ET.SubElement(logentry, 'count')
 adminPlusCount = ET.SubElement(count, 'admin+')
 adminPlusCount.text = len(_adminPlus.intersection(lowercasePlayers))
 adminCount = ET.SubElement(count, 'admin')
 adminCount.text = len(_admin.intersection(lowercasePlayers))
 staffCount = ET.SubElement(count, 'staff')
 staffCount.text = len(_staff.intersection(lowercasePlayers))
 retiredCount = ET.SubElement(count, 'retired')
 retiredCount.text = len(_retired.intersection(lowercasePlayers))
 artisanCount = ET.SubElement(count, 'artisan')
 artisanCount.text = len(_artisan.intersection(lowercasePlayers))
 architectCount = ET.SubElement(count, 'architect')
 architectCount.text = len(_architect.intersection(lowercasePlayers))
 
 for name in _adminPlus.intersection(lowercasePlayers):
     ET.SubElement(logentry, 'admin+').text = name
 
 for name in _admin.intersection(lowercasePlayers):
Exemple #57
0
 def next(self):
     if self.i >= len(self.seqn): raise StopIteration
     v = self.seqn[self.i]
     self.i += 1
     return v
Exemple #58
0
    def test_tee(self):
        n = 200

        def irange(n):
            for i in xrange(n):
                yield i

        a, b = tee([])  # test empty iterator
        self.assertEqual(list(a), [])
        self.assertEqual(list(b), [])

        a, b = tee(irange(n))  # test 100% interleaved
        self.assertEqual(zip(a, b), zip(range(n), range(n)))

        a, b = tee(irange(n))  # test 0% interleaved
        self.assertEqual(list(a), range(n))
        self.assertEqual(list(b), range(n))

        a, b = tee(irange(n))  # test dealloc of leading iterator
        for i in xrange(100):
            self.assertEqual(a.next(), i)
        del a
        self.assertEqual(list(b), range(n))

        a, b = tee(irange(n))  # test dealloc of trailing iterator
        for i in xrange(100):
            self.assertEqual(a.next(), i)
        del b
        self.assertEqual(list(a), range(100, n))

        for j in xrange(5):  # test randomly interleaved
            order = [0] * n + [1] * n
            random.shuffle(order)
            lists = ([], [])
            its = tee(irange(n))
            for i in order:
                value = its[i].next()
                lists[i].append(value)
            self.assertEqual(lists[0], range(n))
            self.assertEqual(lists[1], range(n))

        # test argument format checking
        self.assertRaises(TypeError, tee)
        self.assertRaises(TypeError, tee, 3)
        self.assertRaises(TypeError, tee, [1, 2], 'x')
        self.assertRaises(TypeError, tee, [1, 2], 3, 'x')

        # tee object should be instantiable
        a, b = tee('abc')
        c = type(a)('def')
        self.assertEqual(list(c), list('def'))

        # test long-lagged and multi-way split
        a, b, c = tee(xrange(2000), 3)
        for i in xrange(100):
            self.assertEqual(a.next(), i)
        self.assertEqual(list(b), range(2000))
        self.assertEqual([c.next(), c.next()], range(2))
        self.assertEqual(list(a), range(100, 2000))
        self.assertEqual(list(c), range(2, 2000))

        # test values of n
        self.assertRaises(TypeError, tee, 'abc', 'invalid')
        self.assertRaises(ValueError, tee, [], -1)
        for n in xrange(5):
            result = tee('abc', n)
            self.assertEqual(type(result), tuple)
            self.assertEqual(len(result), n)
            self.assertEqual(map(list, result), [list('abc')] * n)

        # tee pass-through to copyable iterator
        a, b = tee('abc')
        c, d = tee(a)
        self.assert_(a is c)

        # test tee_new
        t1, t2 = tee('abc')
        tnew = type(t1)
        self.assertRaises(TypeError, tnew)
        self.assertRaises(TypeError, tnew, 10)
        t3 = tnew(t1)
        self.assert_(list(t1) == list(t2) == list(t3) == list('abc'))

        # test that tee objects are weak referencable
        a, b = tee(xrange(10))
        p = proxy(a)
        self.assertEqual(getattr(p, '__class__'), type(b))
        del a
        self.assertRaises(ReferenceError, getattr, p, '__class__')