row.py (5240B)

---

 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\carbon\common\script\sys\row.py
 from __future__ import print_function
 from future.utils import raise_
 import sys
 import types
 import unittest
 
 class Row(object):
     __guid__ = 'util.Row'
     __passbyvalue__ = 1
     __slots__ = ('header', 'line')
 
     def __init__(self, header = None, line = None):
         if header and line and len(header) != len(line):
             raise ValueError('header and line must be equal length lists')
         self.header = header or []
         self.line = line or []
 
     def __ne__(self, other):
         return self.__cmp__(other) != 0
 
     def __eq__(self, other):
         return self.__cmp__(other) == 0
 
     def __getattr__(self, name):
         if name in self.__slots__:
             return object.__getattribute__(self, name)
         try:
             return self.line[self.header.index(name)]
         except ValueError:
             raise_(AttributeError, name)
         except KeyError:
             raise_(AttributeError, name)
 
     def __getitem__(self, i):
         if type(i) == types.StringType:
             try:
                 return getattr(self, i)
             except AttributeError:
                 raise KeyError(i)
 
         return self.line[i]
 
     def __setitem__(self, key, value):
         if type(key) == types.StringType:
             return setattr(self, key, value)
         self.line[key] = value
 
     def __setattr__(self, key, value):
         if key in self.__slots__:
             object.__setattr__(self, key, value)
         else:
             try:
                 self.line[self.header.index(key)] = value
             except ValueError:
                 raise AttributeError(key)
 
     def __repr__(self):
         header = self.header
         line = self.line
         if len(header) > len(line):
             return '<Row MANGLED ROW,%s,%r>' % (header, line)
         ret = '<Row '
         for i in range(len(header)):
             ret += '%s:%r,' % (header[i], line[i])
 
         return ret[:-1] + '>'
 
     def __len__(self):
         return len(self.line)
 
     def __getslice__(self, i, j):
         return self.__class__(self.header[i:j], self.line[i:j])
 
     def __cmp__(self, other):
         if type(other) != type(self):
             return NotImplemented
         elif self.header != other.header:
             return cmp(self.header, other.header)
         else:
             return cmp(self.line, other.line)
 
     def __getstate__(self):
         return (self.header, self.line)
 
     def __setstate__(self, state):
         self.header, self.line = state
 
 
 class TestRowConstruction(unittest.TestCase):
 
     def testConstructWithValues(self):
         self.assertTrue(True)
         row = Row(['a', 'b'], [1, 2])
         self.assertEqual(row.header, ['a', 'b'])
         self.assertEqual(row.line, [1, 2])
 
     def testConstructEmpty(self):
         row = Row()
         self.assertEqual(row.header, [])
         self.assertEqual(row.line, [])
 
     def testConstructHeaderOnly(self):
         row = Row(['a', 'b'])
         self.assertEqual(row.header, ['a', 'b'])
         row = Row(['a', 'b'], [])
         self.assertEqual(row.header, ['a', 'b'])
 
     def testConstructWithValuesRequiresEqualLengthLists(self):
         with self.assertRaises(ValueError):
             row = Row(['a', 'b'], [1])
 
 
 class TestRowAccess(unittest.TestCase):
 
     def testAccessByName(self):
         row = Row(['a', 'b'], [1, 2])
         self.assertEqual(row.a, 1)
         self.assertEqual(row.b, 2)
         with self.assertRaises(AttributeError):
             row.c
 
     def testAccessByIndex(self):
         row = Row(['a', 'b'], [1, 2])
         self.assertEqual(row[0], 1)
         self.assertEqual(row[1], 2)
         with self.assertRaises(IndexError):
             row[2]
 
     def testAccessLikeDict(self):
         row = Row(['a', 'b'], [1, 2])
         self.assertEqual(row['a'], 1)
         self.assertEqual(row['b'], 2)
         with self.assertRaises(KeyError):
             row['c']
 
 
 class TestRowMutation(unittest.TestCase):
 
     def testMutateByName(self):
         row = Row(['a', 'b'], [1, 2])
         row.a = 3
         self.assertEqual(row.a, 3)
         self.assertEqual(row.line, [3, 2])
         with self.assertRaises(AttributeError):
             row.c = 4711
 
     def testMutateByIndex(self):
         row = Row(['a', 'b'], [1, 2])
         row[0] = 3
         self.assertEqual(row[0], 3)
         with self.assertRaises(IndexError):
             row[2] = 4711
 
     def testCannotCreateImmutableAttributesThroughDunderDict(self):
         row = Row(['a', 'b'], [1, 2])
         with self.assertRaises(AttributeError):
             row.__dict__['a'] = 4711
 
 
 class TestRowSlicing(unittest.TestCase):
 
     def testSlice(self):
         row = Row(['a', 'b'], [1, 2])
         self.assertEqual(row[:], row)
         self.assertEqual(row[0:1], Row(['a'], [1]))
         self.assertEqual(row[1:], Row(['b'], [2]))
 
 
 class TestRowMarshal(unittest.TestCase):
 
     def testCanMarshal(self):
         import blue
         row = Row(['a', 'b'], [1, 2])
         m = blue.marshal.Save(row)
         try:
             new = blue.marshal.Load(m)
         except Exception as exc:
             print('Could not marshal row: %s' % exc)
 
         self.assertEqual(row, new)