wangwei
/
tods
Not watched
1
0
Fork 0
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 03efe340c9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '03efe340c9'
${ noResults }
tods/d3m/tests/test_containers.py

2609 lines
102 kB
Raw Blame History 

  1. import copy

  2. import os.path

  3. import pickle

  4. import tempfile

  5. import unittest

  6. import warnings

  7. 

  8. import numpy

  9. import pandas

  10. import pandas.core.common

  11. 

  12. from d3m import container, utils

  13. from d3m.container import utils as container_utils

  14. from d3m.metadata import base as metadata_base

  15. 

  16. copy_functions = {

  17.     'obj.copy()': lambda obj: obj.copy(),

  18.     'obj[:]': lambda obj: obj[:],

  19.     'copy.copy()': lambda obj: copy.copy(obj),

  20.     'copy.deepcopy()': lambda obj: copy.deepcopy(obj),

  21.     'pickle.loads(pickle.dumps())': lambda obj: pickle.loads(pickle.dumps(obj)),

  22. }

  23. 

  24. 

  25. class TestContainers(unittest.TestCase):

  26.     def test_list(self):

  27.         l = container.List()

  28. 

  29.         self.assertTrue(hasattr(l, 'metadata'))

  30. 

  31.         l = container.List([1, 2, 3], generate_metadata=True)

  32. 

  33.         l.metadata = l.metadata.update((), {

  34.             'test': 'foobar',

  35.         })

  36. 

  37.         self.assertSequenceEqual(l, [1, 2, 3])

  38.         self.assertIsInstance(l, container.List)

  39.         self.assertTrue(hasattr(l, 'metadata'))

  40.         self.assertEqual(l.metadata.query(()).get('test'), 'foobar')

  41. 

  42.         self.assertIsInstance(l, container.List)

  43.         self.assertIsInstance(l, list)

  44. 

  45.         self.assertNotIsInstance([], container.List)

  46. 

  47.         for name, copy_function in copy_functions.items():

  48.             l_copy = copy_function(l)

  49. 

  50.             self.assertIsInstance(l_copy, container.List, name)

  51.             self.assertTrue(hasattr(l_copy, 'metadata'), name)

  52. 

  53.             self.assertSequenceEqual(l, l_copy, name)

  54.             self.assertEqual(l.metadata.to_internal_json_structure(), l_copy.metadata.to_internal_json_structure(), name)

  55.             self.assertEqual(l_copy.metadata.query(()).get('test'), 'foobar', name)

  56. 

  57.         l_copy = container.List(l, {

  58.             'test2': 'barfoo',

  59.         }, generate_metadata=True)

  60. 

  61.         self.assertIsInstance(l_copy, container.List)

  62.         self.assertTrue(hasattr(l_copy, 'metadata'))

  63. 

  64.         self.assertSequenceEqual(l, l_copy)

  65.         self.assertEqual(l_copy.metadata.query(()), {

  66.             'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  67.             'structural_type': container.List,

  68.             'dimension': {

  69.                 'length': 3,

  70.             },

  71.             'test': 'foobar',

  72.             'test2': 'barfoo',

  73.         })

  74. 

  75.         self.assertEqual(l[1], 2)

  76. 

  77.         with self.assertRaisesRegex(TypeError, 'list indices must be integers or slices, not tuple'):

  78.             l[1, 2]

  79. 

  80.         l_slice = l[1:3]

  81. 

  82.         self.assertSequenceEqual(l, [1, 2, 3])

  83.         self.assertSequenceEqual(l_slice, [2, 3])

  84.         self.assertIsInstance(l_slice, container.List)

  85.         self.assertTrue(hasattr(l_slice, 'metadata'))

  86.         self.assertEqual(l.metadata.to_internal_json_structure(), l_slice.metadata.to_internal_json_structure())

  87. 

  88.         l_added = l + [4, 5]

  89. 

  90.         self.assertSequenceEqual(l, [1, 2, 3])

  91.         self.assertSequenceEqual(l_added, [1, 2, 3, 4, 5])

  92.         self.assertIsInstance(l_added, container.List)

  93.         self.assertTrue(hasattr(l_added, 'metadata'))

  94.         self.assertEqual(l.metadata.to_internal_json_structure(), l_added.metadata.to_internal_json_structure())

  95. 

  96.         l_added += [6, 7]

  97. 

  98.         self.assertSequenceEqual(l_added, [1, 2, 3, 4, 5, 6, 7])

  99.         self.assertIsInstance(l_added, container.List)

  100.         self.assertTrue(hasattr(l_added, 'metadata'))

  101.         self.assertEqual(l.metadata.to_internal_json_structure(), l_added.metadata.to_internal_json_structure())

  102. 

  103.         l_multiplied = l * 3

  104. 

  105.         self.assertSequenceEqual(l, [1, 2, 3])

  106.         self.assertSequenceEqual(l_multiplied, [1, 2, 3, 1, 2, 3, 1, 2, 3])

  107.         self.assertIsInstance(l_multiplied, container.List)

  108.         self.assertTrue(hasattr(l_multiplied, 'metadata'))

  109.         self.assertEqual(l.metadata.to_internal_json_structure(), l_multiplied.metadata.to_internal_json_structure())

  110. 

  111.         l_multiplied = 3 * l

  112. 

  113.         self.assertSequenceEqual(l, [1, 2, 3])

  114.         self.assertSequenceEqual(l_multiplied, [1, 2, 3, 1, 2, 3, 1, 2, 3])

  115.         self.assertIsInstance(l_multiplied, container.List)

  116.         self.assertTrue(hasattr(l_multiplied, 'metadata'))

  117.         self.assertEqual(l.metadata.to_internal_json_structure(), l_multiplied.metadata.to_internal_json_structure())

  118. 

  119.         l_multiplied *= 2

  120. 

  121.         self.assertSequenceEqual(l_multiplied, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])

  122.         self.assertIsInstance(l_multiplied, container.List)

  123.         self.assertTrue(hasattr(l_multiplied, 'metadata'))

  124.         self.assertEqual(l.metadata.to_internal_json_structure(), l_multiplied.metadata.to_internal_json_structure())

  125. 

  126.     def test_ndarray(self):

  127.         array = container.ndarray(numpy.array([1, 2, 3]), generate_metadata=True)

  128.         self.assertTrue(numpy.array_equal(array, [1, 2, 3]))

  129.         self.assertIsInstance(array, container.ndarray)

  130.         self.assertTrue(hasattr(array, 'metadata'))

  131. 

  132.         self.assertIsInstance(array, numpy.ndarray)

  133. 

  134.         self.assertNotIsInstance(numpy.array([]), container.ndarray)

  135. 

  136.         array.metadata = array.metadata.update((), {

  137.             'test': 'foobar',

  138.         })

  139. 

  140.         self.assertEqual(array.metadata.query(()).get('test'), 'foobar')

  141. 

  142.         for name, copy_function in copy_functions.items():

  143.             array_copy = copy_function(array)

  144. 

  145.             self.assertIsInstance(array_copy, container.ndarray, name)

  146.             self.assertTrue(hasattr(array_copy, 'metadata'), name)

  147. 

  148.             self.assertTrue(numpy.array_equal(array, array_copy), name)

  149.             self.assertEqual(array.metadata.to_internal_json_structure(), array_copy.metadata.to_internal_json_structure(), name)

  150.             self.assertEqual(array_copy.metadata.query(()).get('test'), 'foobar', name)

  151. 

  152. 

  153.         array_copy = container.ndarray(array, {

  154.             'test2': 'barfoo',

  155.         }, generate_metadata=True)

  156. 

  157.         self.assertIsInstance(array_copy, container.ndarray)

  158.         self.assertTrue(hasattr(array_copy, 'metadata'))

  159. 

  160.         self.assertTrue(numpy.array_equal(array, array_copy))

  161.         self.assertEqual(array_copy.metadata.query(()), {

  162.             'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  163.             'structural_type': container.ndarray,

  164.             'dimension': {

  165.                 'length': 3,

  166.             },

  167.             'test': 'foobar',

  168.             'test2': 'barfoo',

  169.         })

  170. 

  171.         array_from_list = container.ndarray([1, 2, 3], generate_metadata=True)

  172.         self.assertTrue(numpy.array_equal(array_from_list, [1, 2, 3]))

  173.         self.assertIsInstance(array_from_list, container.ndarray)

  174.         self.assertTrue(hasattr(array_from_list, 'metadata'))

  175. 

  176.     def test_dataframe_to_csv(self):

  177.         df = container.DataFrame(pandas.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]}), generate_metadata=True)

  178.         df.metadata = df.metadata.update((metadata_base.ALL_ELEMENTS, 0), {'name': 'E'})

  179.         df.metadata = df.metadata.update((metadata_base.ALL_ELEMENTS, 1), {'name': 'F'})

  180. 

  181.         self.assertEqual(df.columns.tolist(), ['A', 'B'])

  182.         self.assertEqual(df.to_csv(), 'E,F\n1,4\n2,5\n3,6\n')

  183. 

  184.     def test_dataframe(self):

  185.         df = container.DataFrame(pandas.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}), generate_metadata=True)

  186.         self.assertTrue(df._data.equals(pandas.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})._data))

  187.         self.assertIsInstance(df, container.DataFrame)

  188.         self.assertTrue(hasattr(df, 'metadata'))

  189. 

  190.         self.assertIsInstance(df, pandas.DataFrame)

  191. 

  192.         self.assertNotIsInstance(pandas.DataFrame({'A': [1, 2, 3]}), container.DataFrame)

  193. 

  194.         df.metadata = df.metadata.update((), {

  195.             'test': 'foobar',

  196.         })

  197. 

  198.         self.assertEqual(df.metadata.query(()).get('test'), 'foobar')

  199. 

  200.         for name, copy_function in copy_functions.items():

  201.             df_copy = copy_function(df)

  202. 

  203.             self.assertIsInstance(df_copy, container.DataFrame, name)

  204.             self.assertTrue(hasattr(df_copy, 'metadata'), name)

  205. 

  206.             self.assertTrue(df.equals(df_copy), name)

  207.             self.assertEqual(df.metadata.to_internal_json_structure(), df_copy.metadata.to_internal_json_structure(), name)

  208.             self.assertEqual(df_copy.metadata.query(()).get('test'), 'foobar', name)

  209. 

  210.         df_copy = container.DataFrame(df, {

  211.             'test2': 'barfoo',

  212.         }, generate_metadata=True)

  213. 

  214.         self.assertIsInstance(df_copy, container.DataFrame)

  215.         self.assertTrue(hasattr(df_copy, 'metadata'))

  216. 

  217.         self.assertTrue(numpy.array_equal(df, df_copy))

  218.         self.assertEqual(df_copy.metadata.query(()), {

  219.             'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  220.             'structural_type': container.DataFrame,

  221.             'semantic_types': ('https://metadata.datadrivendiscovery.org/types/Table',),

  222.             'dimension': {

  223.                 'name': 'rows',

  224.                 'semantic_types': ('https://metadata.datadrivendiscovery.org/types/TabularRow',),

  225.                 'length': 3

  226.             },

  227.             'test': 'foobar',

  228.             'test2': 'barfoo',

  229.         })

  230. 

  231.         df_from_dict = container.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}, generate_metadata=True)

  232.         self.assertTrue(df_from_dict._data.equals(pandas.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})._data))

  233.         self.assertIsInstance(df_from_dict, container.DataFrame)

  234.         self.assertTrue(hasattr(df_from_dict, 'metadata'))

  235. 

  236.         # Regression tests to make sure column name cannot overwrite DataFrame

  237.         # attributes we use (like metadata and custom methods).

  238.         dataframe = container.DataFrame({'metadata': [0], 'select_columns': [1]})

  239.         self.assertIsInstance(dataframe.metadata, metadata_base.DataMetadata)

  240.         self.assertIsInstance(dataframe.select_columns([0]), container.DataFrame)

  241.         self.assertEqual(dataframe.loc[0, 'metadata'], 0)

  242.         self.assertEqual(dataframe.loc[0, 'select_columns'], 1)

  243. 

  244.     def test_dataset(self):

  245.         dataset = container.Dataset.load('sklearn://boston')

  246. 

  247.         self.assertIsInstance(dataset, container.Dataset)

  248.         self.assertTrue(hasattr(dataset, 'metadata'))

  249. 

  250.         dataset.metadata = dataset.metadata.update((), {

  251.             'test': 'foobar',

  252.         })

  253. 

  254.         self.assertEqual(dataset.metadata.query(()).get('test'), 'foobar')

  255. 

  256.         for name, copy_function in copy_functions.items():

  257.             # Not supported on dicts.

  258.             if name == 'obj[:]':

  259.                 continue

  260. 

  261.             dataset_copy = copy_function(dataset)

  262. 

  263.             self.assertIsInstance(dataset_copy, container.Dataset, name)

  264.             self.assertTrue(hasattr(dataset_copy, 'metadata'), name)

  265. 

  266.             self.assertEqual(len(dataset), len(dataset_copy), name)

  267.             self.assertEqual(dataset.keys(), dataset_copy.keys(), name)

  268.             for resource_name in dataset.keys():

  269.                 self.assertTrue(numpy.array_equal(dataset[resource_name], dataset_copy[resource_name]), name)

  270.             self.assertEqual(dataset.metadata.to_internal_json_structure(), dataset_copy.metadata.to_internal_json_structure(), name)

  271.             self.assertEqual(dataset_copy.metadata.query(()).get('test'), 'foobar', name)

  272. 

  273.     def test_list_ndarray_int(self):

  274.         # With custom metadata which should be preserved.

  275.         l = container.List([1, 2, 3], {

  276.             'foo': 'bar',

  277.         }, generate_metadata=True)

  278. 

  279.         self.assertEqual(utils.to_json_structure(l.metadata.to_internal_simple_structure()), [{

  280.             'selector': [],

  281.             'metadata': {

  282.                 'foo': 'bar',

  283.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  284.                 'structural_type': 'd3m.container.list.List',

  285.                 'dimension': {

  286.                     'length': 3,

  287.                 },

  288.             },

  289.         }, {

  290.             'selector': ['__ALL_ELEMENTS__'],

  291.             'metadata': {

  292.                 'structural_type': 'int',

  293.             },

  294.         }])

  295. 

  296.         array = container.ndarray(l, generate_metadata=True)

  297. 

  298.         self.assertEqual(utils.to_json_structure(array.metadata.to_internal_simple_structure()), [{

  299.             'selector': [],

  300.             'metadata': {

  301.                 'foo': 'bar',

  302.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  303.                 'structural_type': 'd3m.container.numpy.ndarray',

  304.                 'dimension': {

  305.                     'length': 3,

  306.                 },

  307.             },

  308.         }, {

  309.             'selector': ['__ALL_ELEMENTS__'],

  310.             'metadata': {

  311.                 'structural_type': 'numpy.int64',

  312.             },

  313.         }])

  314. 

  315.         l2 = container.List(array, generate_metadata=True)

  316. 

  317.         self.assertEqual(utils.to_json_structure(l2.metadata.to_internal_simple_structure()), [{

  318.             'selector': [],

  319.             'metadata': {

  320.                 'foo': 'bar',

  321.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  322.                 'structural_type': 'd3m.container.list.List',

  323.                 'dimension': {

  324.                     'length': 3,

  325.                 },

  326.             },

  327.         }, {

  328.             'selector': ['__ALL_ELEMENTS__'],

  329.             'metadata': {

  330.                 'structural_type': 'numpy.int64',

  331.             },

  332.         }])

  333. 

  334.     def test_dataframe_ndarray_int_noncompact_metadata(self):

  335.         # With custom metadata which should be preserved.

  336.         df = container.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}, {

  337.             'foo': 'bar',

  338.         }, generate_metadata=False)

  339. 

  340.         df.metadata = df.metadata.generate(df, compact=False)

  341. 

  342.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  343.             'selector': [],

  344.             'metadata': {

  345.                 'foo': 'bar',

  346.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  347.                 'structural_type': 'd3m.container.pandas.DataFrame',

  348.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  349.                 'dimension': {

  350.                     'name': 'rows',

  351.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  352.                     'length': 3,

  353.                 },

  354.             },

  355.         }, {

  356.             'selector': ['__ALL_ELEMENTS__'],

  357.             'metadata': {

  358.                 'dimension': {

  359.                     'name': 'columns',

  360.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  361.                     'length': 3,

  362.                 },

  363.             },

  364.         }, {

  365.             'selector': ['__ALL_ELEMENTS__', 0],

  366.             'metadata': {

  367.                 'name': 'A',

  368.                 'structural_type': 'numpy.int64',

  369.             },

  370.         }, {

  371.             'selector': ['__ALL_ELEMENTS__', 1],

  372.             'metadata': {

  373.                 'name': 'B',

  374.                 'structural_type': 'numpy.int64',

  375.             },

  376.         }, {

  377.             'selector': ['__ALL_ELEMENTS__', 2],

  378.             'metadata': {

  379.                 'name': 'C',

  380.                 'structural_type': 'numpy.int64',

  381.             },

  382.         }])

  383. 

  384.         array = container.ndarray(df, generate_metadata=False)

  385. 

  386.         array.metadata = array.metadata.generate(array, compact=False)

  387. 

  388.         self.assertEqual(utils.to_json_structure(array.metadata.to_internal_simple_structure()), [{

  389.             'selector': [],

  390.             'metadata': {

  391.                 'foo': 'bar',

  392.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  393.                 'structural_type': 'd3m.container.numpy.ndarray',

  394.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  395.                 'dimension': {

  396.                     'name': 'rows',

  397.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  398.                     'length': 3,

  399.                 },

  400.             },

  401.         }, {

  402.             'selector': ['__ALL_ELEMENTS__'],

  403.             'metadata': {

  404.                 'dimension': {

  405.                     'name': 'columns',

  406.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  407.                     'length': 3,

  408.                 },

  409.             },

  410.         }, {

  411.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  412.             'metadata': {

  413.                 'structural_type': 'numpy.int64',

  414.             },

  415.         }, {

  416.             'selector': ['__ALL_ELEMENTS__', 0],

  417.             'metadata': {

  418.                 'name': 'A',

  419.             },

  420.         }, {

  421.             'selector': ['__ALL_ELEMENTS__', 1],

  422.             'metadata': {

  423.                 'name': 'B',

  424.             },

  425.         }, {

  426.             'selector': ['__ALL_ELEMENTS__', 2],

  427.             'metadata': {

  428.                 'name': 'C',

  429.             },

  430.         }])

  431. 

  432.         df2 = container.DataFrame(array, generate_metadata=False)

  433. 

  434.         df2.metadata = df2.metadata.generate(df2, compact=False)

  435. 

  436.         self.assertEqual(utils.to_json_structure(df2.metadata.to_internal_simple_structure()), [{

  437.             'selector': [],

  438.             'metadata': {

  439.                 'foo': 'bar',

  440.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  441.                 'structural_type': 'd3m.container.pandas.DataFrame',

  442.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  443.                 'dimension': {

  444.                     'name': 'rows',

  445.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  446.                     'length': 3,

  447.                 },

  448.             },

  449.         }, {

  450.             'selector': ['__ALL_ELEMENTS__'],

  451.             'metadata': {

  452.                 'dimension': {

  453.                     'name': 'columns',

  454.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  455.                     'length': 3,

  456.                 },

  457.             },

  458.         }, {

  459.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  460.             'metadata': {

  461.                 'structural_type': 'numpy.int64',

  462.             },

  463.         }, {

  464.             'selector': ['__ALL_ELEMENTS__', 0],

  465.             'metadata': {

  466.                 'name': 'A',

  467.                 'structural_type': 'numpy.int64',

  468.             },

  469.         }, {

  470.             'selector': ['__ALL_ELEMENTS__', 1],

  471.             'metadata': {

  472.                 'name': 'B',

  473.                 'structural_type': 'numpy.int64',

  474.             },

  475.         }, {

  476.             'selector': ['__ALL_ELEMENTS__', 2],

  477.             'metadata': {

  478.                 'name': 'C',

  479.                 'structural_type': 'numpy.int64',

  480.             },

  481.         }])

  482. 

  483.     def test_dataframe_ndarray_int_compact_metadata(self):

  484.         # With custom metadata which should be preserved.

  485.         df = container.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}, {

  486.             'foo': 'bar',

  487.         }, generate_metadata=False)

  488. 

  489.         df.metadata = df.metadata.generate(df, compact=True)

  490. 

  491.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  492.             'selector': [],

  493.             'metadata': {

  494.                 'foo': 'bar',

  495.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  496.                 'structural_type': 'd3m.container.pandas.DataFrame',

  497.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  498.                 'dimension': {

  499.                     'name': 'rows',

  500.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  501.                     'length': 3,

  502.                 },

  503.             },

  504.         }, {

  505.             'selector': ['__ALL_ELEMENTS__'],

  506.             'metadata': {

  507.                 'dimension': {

  508.                     'name': 'columns',

  509.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  510.                     'length': 3,

  511.                 },

  512.             },

  513.         }, {

  514.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  515.             'metadata': {

  516.                 'structural_type': 'numpy.int64',

  517.             },

  518.         }, {

  519.             'selector': ['__ALL_ELEMENTS__', 0],

  520.             'metadata': {

  521.                 'name': 'A',

  522.             },

  523.         }, {

  524.             'selector': ['__ALL_ELEMENTS__', 1],

  525.             'metadata': {

  526.                 'name': 'B',

  527.             },

  528.         }, {

  529.             'selector': ['__ALL_ELEMENTS__', 2],

  530.             'metadata': {

  531.                 'name': 'C',

  532.             },

  533.         }])

  534. 

  535.         array = container.ndarray(df, generate_metadata=False)

  536. 

  537.         array.metadata = array.metadata.generate(array, compact=True)

  538. 

  539.         self.assertEqual(utils.to_json_structure(array.metadata.to_internal_simple_structure()), [{

  540.             'selector': [],

  541.             'metadata': {

  542.                 'foo': 'bar',

  543.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  544.                 'structural_type': 'd3m.container.numpy.ndarray',

  545.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  546.                 'dimension': {

  547.                     'name': 'rows',

  548.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  549.                     'length': 3,

  550.                 },

  551.             },

  552.         }, {

  553.             'selector': ['__ALL_ELEMENTS__'],

  554.             'metadata': {

  555.                 'dimension': {

  556.                     'name': 'columns',

  557.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  558.                     'length': 3,

  559.                 },

  560.             },

  561.         }, {

  562.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  563.             'metadata': {

  564.                 'structural_type': 'numpy.int64',

  565.             },

  566.         }, {

  567.             'selector': ['__ALL_ELEMENTS__', 0],

  568.             'metadata': {

  569.                 'name': 'A',

  570.             },

  571.         }, {

  572.             'selector': ['__ALL_ELEMENTS__', 1],

  573.             'metadata': {

  574.                 'name': 'B',

  575.             },

  576.         }, {

  577.             'selector': ['__ALL_ELEMENTS__', 2],

  578.             'metadata': {

  579.                 'name': 'C',

  580.             },

  581.         }])

  582. 

  583.         df2 = container.DataFrame(array, generate_metadata=False)

  584. 

  585.         df2.metadata = df2.metadata.generate(df2, compact=True)

  586. 

  587.         self.assertEqual(utils.to_json_structure(df2.metadata.to_internal_simple_structure()), [{

  588.             'selector': [],

  589.             'metadata': {

  590.                 'foo': 'bar',

  591.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  592.                 'structural_type': 'd3m.container.pandas.DataFrame',

  593.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  594.                 'dimension': {

  595.                     'name': 'rows',

  596.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  597.                     'length': 3,

  598.                 },

  599.             },

  600.         }, {

  601.             'selector': ['__ALL_ELEMENTS__'],

  602.             'metadata': {

  603.                 'dimension': {

  604.                     'name': 'columns',

  605.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  606.                     'length': 3,

  607.                 },

  608.             },

  609.         }, {

  610.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  611.             'metadata': {

  612.                 'structural_type': 'numpy.int64',

  613.             },

  614.         }, {

  615.             'selector': ['__ALL_ELEMENTS__', 0],

  616.             'metadata': {

  617.                 'name': 'A',

  618.             },

  619.         }, {

  620.             'selector': ['__ALL_ELEMENTS__', 1],

  621.             'metadata': {

  622.                 'name': 'B',

  623.             },

  624.         }, {

  625.             'selector': ['__ALL_ELEMENTS__', 2],

  626.             'metadata': {

  627.                 'name': 'C',

  628.             },

  629.         }])

  630. 

  631.     def test_dataframe_list_int_compact_metadata(self):

  632.         # With custom metadata which should be preserved.

  633.         df = container.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}, {

  634.             'foo': 'bar',

  635.         }, generate_metadata=False)

  636. 

  637.         df.metadata = df.metadata.generate(df, compact=True)

  638. 

  639.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  640.             'selector': [],

  641.             'metadata': {

  642.                 'foo': 'bar',

  643.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  644.                 'structural_type': 'd3m.container.pandas.DataFrame',

  645.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  646.                 'dimension': {

  647.                     'name': 'rows',

  648.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  649.                     'length': 3,

  650.                 },

  651.             },

  652.         }, {

  653.             'selector': ['__ALL_ELEMENTS__'],

  654.             'metadata': {

  655.                 'dimension': {

  656.                     'name': 'columns',

  657.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  658.                     'length': 3,

  659.                 },

  660.             },

  661.         }, {

  662.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  663.             'metadata': {

  664.                 'structural_type': 'numpy.int64',

  665.             },

  666.         }, {

  667.             'selector': ['__ALL_ELEMENTS__', 0],

  668.             'metadata': {

  669.                 'name': 'A',

  670.             },

  671.         }, {

  672.             'selector': ['__ALL_ELEMENTS__', 1],

  673.             'metadata': {

  674.                 'name': 'B',

  675.             },

  676.         }, {

  677.             'selector': ['__ALL_ELEMENTS__', 2],

  678.             'metadata': {

  679.                 'name': 'C',

  680.             },

  681.         }])

  682. 

  683.         l = container.List(df, generate_metadata=False)

  684. 

  685.         l.metadata = l.metadata.generate(l, compact=True)

  686. 

  687.         self.assertEqual(utils.to_json_structure(l.metadata.to_internal_simple_structure()), [{

  688.             'selector': [],

  689.             'metadata': {

  690.                 'foo': 'bar',

  691.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  692.                 'structural_type': 'd3m.container.list.List',

  693.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  694.                 'dimension': {

  695.                     'name': 'rows',

  696.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  697.                     'length': 3,

  698.                 },

  699.             },

  700.         }, {

  701.             'selector': ['__ALL_ELEMENTS__'],

  702.             'metadata': {

  703.                 'structural_type': 'd3m.container.list.List',

  704.                 'dimension': {

  705.                     'name': 'columns',

  706.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  707.                     'length': 3,

  708.                 },

  709.             },

  710.         }, {

  711.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  712.             'metadata': {

  713.                 'structural_type': 'int',

  714.             },

  715.         }, {

  716.             'selector': ['__ALL_ELEMENTS__', 0],

  717.             'metadata': {

  718.                 'name': 'A',

  719.             },

  720.         }, {

  721.             'selector': ['__ALL_ELEMENTS__', 1],

  722.             'metadata': {

  723.                 'name': 'B',

  724.             },

  725.         }, {

  726.             'selector': ['__ALL_ELEMENTS__', 2],

  727.             'metadata': {

  728.                 'name': 'C',

  729.             },

  730.         }])

  731. 

  732.         df2 = container.DataFrame(l, generate_metadata=False)

  733. 

  734.         df2.metadata = df2.metadata.generate(df2, compact=True)

  735. 

  736.         self.assertEqual(utils.to_json_structure(df2.metadata.to_internal_simple_structure()), [{

  737.             'selector': [],

  738.             'metadata': {

  739.                 'foo': 'bar',

  740.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  741.                 'structural_type': 'd3m.container.pandas.DataFrame',

  742.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  743.                 'dimension': {

  744.                     'name': 'rows',

  745.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  746.                     'length': 3,

  747.                 },

  748.             },

  749.         }, {

  750.             'selector': ['__ALL_ELEMENTS__'],

  751.             'metadata': {

  752.                 'dimension': {

  753.                     'name': 'columns',

  754.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  755.                     'length': 3,

  756.                 },

  757.                 # This is not really required, but current implementation adds it.

  758.                 # It is OK if in the future this gets removed.

  759.                 'structural_type': '__NO_VALUE__',

  760.             },

  761.         }, {

  762.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  763.             'metadata': {

  764.                 'structural_type': 'numpy.int64',

  765.             },

  766.         }, {

  767.             'selector': ['__ALL_ELEMENTS__', 0],

  768.             'metadata': {

  769.                 'name': 'A',

  770.             },

  771.         }, {

  772.             'selector': ['__ALL_ELEMENTS__', 1],

  773.             'metadata': {

  774.                 'name': 'B',

  775.             },

  776.         }, {

  777.             'selector': ['__ALL_ELEMENTS__', 2],

  778.             'metadata': {

  779.                 'name': 'C',

  780.             },

  781.         }])

  782. 

  783.     def test_dataframe_list_int_noncompact_metadata(self):

  784.         # With custom metadata which should be preserved.

  785.         df = container.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]}, {

  786.             'foo': 'bar',

  787.         }, generate_metadata=False)

  788. 

  789.         df.metadata = df.metadata.generate(df, compact=False)

  790. 

  791.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  792.             'selector': [],

  793.             'metadata': {

  794.                 'foo': 'bar',

  795.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  796.                 'structural_type': 'd3m.container.pandas.DataFrame',

  797.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  798.                 'dimension': {

  799.                     'name': 'rows',

  800.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  801.                     'length': 3,

  802.                 },

  803.             },

  804.         }, {

  805.             'selector': ['__ALL_ELEMENTS__'],

  806.             'metadata': {

  807.                 'dimension': {

  808.                     'name': 'columns',

  809.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  810.                     'length': 3,

  811.                 },

  812.             },

  813.         }, {

  814.             'selector': ['__ALL_ELEMENTS__', 0],

  815.             'metadata': {

  816.                 'name': 'A',

  817.                 'structural_type': 'numpy.int64',

  818.             },

  819.         }, {

  820.             'selector': ['__ALL_ELEMENTS__', 1],

  821.             'metadata': {

  822.                 'name': 'B',

  823.                 'structural_type': 'numpy.int64',

  824.             },

  825.         }, {

  826.             'selector': ['__ALL_ELEMENTS__', 2],

  827.             'metadata': {

  828.                 'name': 'C',

  829.                 'structural_type': 'numpy.int64',

  830.             },

  831.         }])

  832. 

  833.         l = container.List(df, generate_metadata=False)

  834. 

  835.         l.metadata = l.metadata.generate(l, compact=False)

  836. 

  837.         self.assertEqual(utils.to_json_structure(l.metadata.to_internal_simple_structure()), [{

  838.             'selector': [],

  839.             'metadata': {

  840.                 'foo': 'bar',

  841.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  842.                 'structural_type': 'd3m.container.list.List',

  843.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  844.                 'dimension': {

  845.                     'name': 'rows',

  846.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  847.                     'length': 3,

  848.                 },

  849.             },

  850.         }, {

  851.             'selector': ['__ALL_ELEMENTS__'],

  852.             'metadata': {

  853.                 'structural_type': 'd3m.container.list.List',

  854.                 'dimension': {

  855.                     'name': 'columns',

  856.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  857.                     'length': 3,

  858.                 },

  859.             },

  860.         }, {

  861.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  862.             'metadata': {

  863.                 'structural_type': 'int',

  864.             },

  865.         }, {

  866.             'selector': ['__ALL_ELEMENTS__', 0],

  867.             'metadata': {

  868.                 'name': 'A',

  869.             },

  870.         }, {

  871.             'selector': ['__ALL_ELEMENTS__', 1],

  872.             'metadata': {

  873.                 'name': 'B',

  874.             },

  875.         }, {

  876.             'selector': ['__ALL_ELEMENTS__', 2],

  877.             'metadata': {

  878.                 'name': 'C',

  879.             },

  880.         }])

  881. 

  882.         df2 = container.DataFrame(l, generate_metadata=False)

  883. 

  884.         df2.metadata = df2.metadata.generate(df2, compact=False)

  885. 

  886.         self.assertEqual(utils.to_json_structure(df2.metadata.to_internal_simple_structure()), [{

  887.             'selector': [],

  888.             'metadata': {

  889.                 'foo': 'bar',

  890.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  891.                 'structural_type': 'd3m.container.pandas.DataFrame',

  892.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  893.                 'dimension': {

  894.                     'name': 'rows',

  895.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  896.                     'length': 3,

  897.                 },

  898.             },

  899.         }, {

  900.             'selector': ['__ALL_ELEMENTS__'],

  901.             'metadata': {

  902.                 'dimension': {

  903.                     'name': 'columns',

  904.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  905.                     'length': 3,

  906.                 },

  907.                 # This is not really required, but current implementation adds it.

  908.                 # It is OK if in the future this gets removed.

  909.                 'structural_type': '__NO_VALUE__',

  910.             },

  911.         }, {

  912.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  913.             'metadata': {

  914.                 'structural_type': 'int',

  915.             },

  916.         }, {

  917.             'selector': ['__ALL_ELEMENTS__', 0],

  918.             'metadata': {

  919.                 'name': 'A',

  920.                 'structural_type': 'numpy.int64',

  921.             },

  922.         }, {

  923.             'selector': ['__ALL_ELEMENTS__', 1],

  924.             'metadata': {

  925.                 'name': 'B',

  926.                 'structural_type': 'numpy.int64',

  927.             },

  928.         }, {

  929.             'selector': ['__ALL_ELEMENTS__', 2],

  930.             'metadata': {

  931.                 'name': 'C',

  932.                 'structural_type': 'numpy.int64',

  933.             },

  934.         }])

  935. 

  936.     def test_deep_ndarray_compact_metadata(self):

  937.         # With custom metadata which should be preserved.

  938.         array = container.ndarray(numpy.arange(3 * 4 * 5 * 5 * 5).reshape((3, 4, 5, 5, 5)), {

  939.             'foo': 'bar',

  940.         }, generate_metadata=False)

  941.         array.metadata = array.metadata.generate(array, compact=True)

  942. 

  943.         self.assertEqual(utils.to_json_structure(array.metadata.to_internal_simple_structure()), [{

  944.             'selector': [],

  945.             'metadata': {

  946.                 'foo': 'bar',

  947.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  948.                 'structural_type': 'd3m.container.numpy.ndarray',

  949.                 'dimension': {

  950.                     'length': 3,

  951.                 },

  952.             },

  953.         }, {

  954.             'selector': ['__ALL_ELEMENTS__'],

  955.             'metadata': {

  956.                 'dimension': {

  957.                     'length': 4,

  958.                 },

  959.             },

  960.         }, {

  961.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  962.             'metadata': {

  963.                 'dimension': {

  964.                     'length': 5,

  965.                 },

  966.             },

  967.         }, {

  968.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  969.             'metadata': {

  970.                 'dimension': {

  971.                     'length': 5,

  972.                 },

  973.             },

  974.         }, {

  975.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  976.             'metadata': {

  977.                 'dimension': {

  978.                     'length': 5,

  979.                 },

  980.             },

  981.         }, {

  982.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  983.             'metadata': {

  984.                 'structural_type': 'numpy.int64',

  985.             },

  986.         }])

  987. 

  988.         df = container.DataFrame(array, generate_metadata=False)

  989.         df.metadata = df.metadata.generate(df, compact=True)

  990. 

  991.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  992.             'selector': [],

  993.             'metadata': {

  994.                 'foo': 'bar',

  995.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  996.                 'structural_type': 'd3m.container.pandas.DataFrame',

  997.                 'dimension': {

  998.                     'length': 3,

  999.                     'name': 'rows',

  1000.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1001.                 },

  1002.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1003.             },

  1004.         }, {

  1005.             'selector': ['__ALL_ELEMENTS__'],

  1006.             'metadata': {

  1007.                 'dimension': {

  1008.                     'length': 4,

  1009.                     'name': 'columns',

  1010.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1011.                 },

  1012.             },

  1013.         }, {

  1014.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1015.             'metadata': {

  1016.                 'dimension': {

  1017.                     'length': 5,

  1018.                 },

  1019.                 'structural_type': 'd3m.container.numpy.ndarray',

  1020.             },

  1021.         }, {

  1022.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1023.             'metadata': {

  1024.                 'dimension': {

  1025.                     'length': 5,

  1026.                 },

  1027.             },

  1028.         }, {

  1029.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1030.             'metadata': {

  1031.                 'dimension': {

  1032.                     'length': 5,

  1033.                 },

  1034.             },

  1035.         }, {

  1036.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1037.             'metadata': {

  1038.                 'structural_type': 'numpy.int64',

  1039.             },

  1040.         }])

  1041. 

  1042.         array2 = container.ndarray(df, generate_metadata=False)

  1043.         array2.metadata = array2.metadata.generate(array2, compact=True)

  1044. 

  1045.         # We do not automatically compact numpy with nested numpy arrays into one array

  1046.         # (there might be an exception if array is jagged).

  1047.         self.assertEqual(utils.to_json_structure(array2.metadata.to_internal_simple_structure()), [{

  1048.             'selector': [],

  1049.             'metadata': {

  1050.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1051.                 'structural_type': 'd3m.container.numpy.ndarray',

  1052.                 'dimension': {

  1053.                     'length': 3,

  1054.                     'name': 'rows',

  1055.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1056.                 },

  1057.                 'foo': 'bar',

  1058.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1059.             },

  1060.         }, {

  1061.             'selector': ['__ALL_ELEMENTS__'],

  1062.             'metadata': {

  1063.                 'dimension': {

  1064.                     'length': 4,

  1065.                     'name': 'columns',

  1066.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1067.                 },

  1068.             },

  1069.         }, {

  1070.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1071.             'metadata': {

  1072.                 'dimension': {

  1073.                     'length': 5,

  1074.                 },

  1075.                 'structural_type': 'd3m.container.numpy.ndarray',

  1076.             },

  1077.         }, {

  1078.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1079.             'metadata': {

  1080.                 'dimension': {

  1081.                     'length': 5,

  1082.                 },

  1083.             },

  1084.         }, {

  1085.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1086.             'metadata': {

  1087.                 'dimension': {

  1088.                     'length': 5,

  1089.                 },

  1090.             },

  1091.         }, {

  1092.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1093.             'metadata': {

  1094.                 'structural_type': 'numpy.int64',

  1095.             },

  1096.         }])

  1097. 

  1098.     def test_deep_ndarray_noncompact_metadata(self):

  1099.         # With custom metadata which should be preserved.

  1100.         array = container.ndarray(numpy.arange(3 * 4 * 5 * 5 * 5).reshape((3, 4, 5, 5, 5)), {

  1101.             'foo': 'bar',

  1102.         }, generate_metadata=False)

  1103.         array.metadata = array.metadata.generate(array, compact=False)

  1104. 

  1105.         self.assertEqual(utils.to_json_structure(array.metadata.to_internal_simple_structure()), [{

  1106.             'selector': [],

  1107.             'metadata': {

  1108.                 'foo': 'bar',

  1109.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1110.                 'structural_type': 'd3m.container.numpy.ndarray',

  1111.                 'dimension': {

  1112.                     'length': 3,

  1113.                 },

  1114.             },

  1115.         }, {

  1116.             'selector': ['__ALL_ELEMENTS__'],

  1117.             'metadata': {

  1118.                 'dimension': {

  1119.                     'length': 4,

  1120.                 },

  1121.             },

  1122.         }, {

  1123.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1124.             'metadata': {

  1125.                 'dimension': {

  1126.                     'length': 5,

  1127.                 },

  1128.             },

  1129.         }, {

  1130.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1131.             'metadata': {

  1132.                 'dimension': {

  1133.                     'length': 5,

  1134.                 },

  1135.             },

  1136.         }, {

  1137.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1138.             'metadata': {

  1139.                 'dimension': {

  1140.                     'length': 5,

  1141.                 },

  1142.             },

  1143.         }, {

  1144.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1145.             'metadata': {

  1146.                 'structural_type': 'numpy.int64',

  1147.             },

  1148.         }])

  1149. 

  1150.         df = container.DataFrame(array, generate_metadata=False)

  1151.         df.metadata = df.metadata.generate(df, compact=False)

  1152. 

  1153.         self.assertEqual(utils.to_json_structure(df.metadata.to_internal_simple_structure()), [{

  1154.             'selector': [],

  1155.             'metadata': {

  1156.                 'foo': 'bar',

  1157.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1158.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1159.                 'dimension': {

  1160.                     'length': 3,

  1161.                     'name': 'rows',

  1162.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1163.                 },

  1164.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1165.             },

  1166.         }, {

  1167.             'selector': ['__ALL_ELEMENTS__'],

  1168.             'metadata': {

  1169.                 'dimension': {

  1170.                     'length': 4,

  1171.                     'name': 'columns',

  1172.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1173.                 },

  1174.             },

  1175.         }, {

  1176.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1177.             'metadata': {

  1178.                 'dimension': {

  1179.                     'length': 5,

  1180.                 },

  1181.             },

  1182.         }, {

  1183.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1184.             'metadata': {

  1185.                 'dimension': {

  1186.                     'length': 5,

  1187.                 },

  1188.             },

  1189.         }, {

  1190.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1191.             'metadata': {

  1192.                 'dimension': {

  1193.                     'length': 5,

  1194.                 },

  1195.             },

  1196.         }, {

  1197.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1198.             'metadata': {

  1199.                 'structural_type': 'numpy.int64',

  1200.             },

  1201.         }, {

  1202.             'selector': ['__ALL_ELEMENTS__', 0],

  1203.             'metadata': {

  1204.                 'dimension': {

  1205.                     'length': 5,

  1206.                 },

  1207.                 'structural_type': 'd3m.container.numpy.ndarray',

  1208.             },

  1209.         }, {

  1210.             'selector': ['__ALL_ELEMENTS__', 0, '__ALL_ELEMENTS__'],

  1211.             'metadata': {

  1212.                 'dimension': {

  1213.                     'length': 5,

  1214.                 },

  1215.             },

  1216.         }, {

  1217.             'selector': ['__ALL_ELEMENTS__', 0, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1218.             'metadata': {

  1219.                 'dimension': {

  1220.                     'length': 5,

  1221.                 },

  1222.             },

  1223.         }, {

  1224.             'selector': ['__ALL_ELEMENTS__', 0, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1225.             'metadata': {

  1226.                 'structural_type': 'numpy.int64',

  1227.             },

  1228.         }, {

  1229.             'selector': ['__ALL_ELEMENTS__', 1],

  1230.             'metadata': {

  1231.                 'dimension': {

  1232.                     'length': 5,

  1233.                 },

  1234.                 'structural_type': 'd3m.container.numpy.ndarray',

  1235.             },

  1236.         }, {

  1237.             'selector': ['__ALL_ELEMENTS__', 1, '__ALL_ELEMENTS__'],

  1238.             'metadata': {

  1239.                 'dimension': {

  1240.                     'length': 5,

  1241.                 },

  1242.             },

  1243.         }, {

  1244.             'selector': ['__ALL_ELEMENTS__', 1, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1245.             'metadata': {

  1246.                 'dimension': {

  1247.                     'length': 5,

  1248.                 },

  1249.             },

  1250.         }, {

  1251.             'selector': ['__ALL_ELEMENTS__', 1, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1252.             'metadata': {

  1253.                 'structural_type': 'numpy.int64',

  1254.             },

  1255.         }, {

  1256.             'selector': ['__ALL_ELEMENTS__', 2],

  1257.             'metadata': {

  1258.                 'dimension': {

  1259.                     'length': 5,

  1260.                 },

  1261.                 'structural_type': 'd3m.container.numpy.ndarray',

  1262.             },

  1263.         }, {

  1264.             'selector': ['__ALL_ELEMENTS__', 2, '__ALL_ELEMENTS__'],

  1265.             'metadata': {

  1266.                 'dimension': {

  1267.                     'length': 5,

  1268.                 },

  1269.             },

  1270.         }, {

  1271.             'selector': ['__ALL_ELEMENTS__', 2, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1272.             'metadata': {

  1273.                 'dimension': {

  1274.                     'length': 5,

  1275.                 },

  1276.             },

  1277.         }, {

  1278.             'selector': ['__ALL_ELEMENTS__', 2, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1279.             'metadata': {

  1280.                 'structural_type': 'numpy.int64',

  1281.             },

  1282.         }, {

  1283.             'selector': ['__ALL_ELEMENTS__', 3],

  1284.             'metadata': {

  1285.                 'dimension': {

  1286.                     'length': 5,

  1287.                 },

  1288.                 'structural_type': 'd3m.container.numpy.ndarray',

  1289.             },

  1290.         }, {

  1291.             'selector': ['__ALL_ELEMENTS__', 3, '__ALL_ELEMENTS__'],

  1292.             'metadata': {

  1293.                 'dimension': {

  1294.                     'length': 5,

  1295.                 },

  1296.             },

  1297.         }, {

  1298.             'selector': ['__ALL_ELEMENTS__', 3, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1299.             'metadata': {

  1300.                 'dimension': {

  1301.                     'length': 5,

  1302.                 },

  1303.             },

  1304.         }, {

  1305.             'selector': ['__ALL_ELEMENTS__', 3, '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1306.             'metadata': {

  1307.                 'structural_type': 'numpy.int64',

  1308.             },

  1309.         }])

  1310. 

  1311.         array2 = container.ndarray(df, generate_metadata=False)

  1312.         array2.metadata = array2.metadata.generate(array2, compact=False)

  1313. 

  1314.         # We do not automatically compact numpy with nested numpy arrays into one array

  1315.         # (there might be an exception if array is jagged).

  1316.         self.assertEqual(utils.to_json_structure(array2.metadata.to_internal_simple_structure()), [{

  1317.             'selector': [],

  1318.             'metadata': {

  1319.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1320.                 'structural_type': 'd3m.container.numpy.ndarray',

  1321.                 'dimension': {

  1322.                     'length': 3,

  1323.                     'name': 'rows',

  1324.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1325.                 },

  1326.                 'foo': 'bar',

  1327.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1328.             },

  1329.         }, {

  1330.             'selector': ['__ALL_ELEMENTS__'],

  1331.             'metadata': {

  1332.                 'dimension': {

  1333.                     'length': 4,

  1334.                     'name': 'columns',

  1335.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1336.                 },

  1337.             },

  1338.         }, {

  1339.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1340.             'metadata': {

  1341.                 'dimension': {

  1342.                     'length': 5,

  1343.                 },

  1344.                 'structural_type': 'd3m.container.numpy.ndarray',

  1345.             },

  1346.         }, {

  1347.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1348.             'metadata': {

  1349.                 'dimension': {

  1350.                     'length': 5,

  1351.                 },

  1352.             },

  1353.         }, {

  1354.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1355.             'metadata': {

  1356.                 'dimension': {

  1357.                     'length': 5,

  1358.                 },

  1359.             },

  1360.         }, {

  1361.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1362.             'metadata': {

  1363.                 'structural_type': 'numpy.int64',

  1364.             },

  1365.         }])

  1366. 

  1367.     def test_simple_list_to_dataframe(self):

  1368.         data = container.List([1, 2, 3], generate_metadata=True)

  1369. 

  1370.         dataframe = container.DataFrame(data, generate_metadata=False)

  1371. 

  1372.         compact_metadata = dataframe.metadata.generate(dataframe, compact=True)

  1373.         noncompact_metadata = dataframe.metadata.generate(dataframe, compact=False)

  1374. 

  1375.         expected_metadata = [{

  1376.             'selector': [],

  1377.             'metadata': {

  1378.                 'schema': 'https://metadata.datadrivendiscovery.org/schemas/v0/container.json',

  1379.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1380.                 'dimension': {

  1381.                     'length': 3,

  1382.                     'name': 'rows',

  1383.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1384.                 },

  1385.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1386.             },

  1387.         }, {

  1388.             'selector': ['__ALL_ELEMENTS__'],

  1389.             'metadata': {

  1390.                 'structural_type': '__NO_VALUE__',

  1391.                 'dimension': {

  1392.                     'name': 'columns',

  1393.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1394.                     'length': 1,

  1395.                 },

  1396.             },

  1397.         }, {

  1398.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1399.             'metadata': {

  1400.                 'structural_type': 'numpy.int64',

  1401.             },

  1402.         }]

  1403. 

  1404.         self.assertEqual(utils.to_json_structure(compact_metadata.to_internal_simple_structure()), expected_metadata)

  1405. 

  1406.         expected_metadata[2]['selector'] = ['__ALL_ELEMENTS__', 0]

  1407. 

  1408.         self.assertEqual(utils.to_json_structure(noncompact_metadata.to_internal_simple_structure()), expected_metadata)

  1409. 

  1410.     def test_select_columns_compact_metadata(self):

  1411.         data = container.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]}, generate_metadata=False)

  1412. 

  1413.         data.metadata = data.metadata.generate(data, compact=True)

  1414. 

  1415.         data.metadata = data.metadata.update_column(0, {'name': 'aaa'})

  1416.         data.metadata = data.metadata.update_column(1, {'name': 'bbb'})

  1417.         data.metadata = data.metadata.update_column(2, {'name': 'ccc'})

  1418.         data.metadata = data.metadata.update((0, 0), {'row': '1'})

  1419.         data.metadata = data.metadata.update((1, 0), {'row': '2'})

  1420.         data.metadata = data.metadata.update((2, 0), {'row': '3'})

  1421.         data.metadata = data.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  1422. 

  1423.         data_metadata_before = data.metadata.to_internal_json_structure()

  1424. 

  1425.         # Test "select_columns" working with a tuple. Specifically, iloc[:, tuple(1)] does not work

  1426.         # (i.e. throws "{IndexingError}Too many indexers"), but iloc[:, 1] and iloc[:, [1]] work.

  1427.         selected = data.select_columns(tuple([1, 0, 2, 1]))

  1428. 

  1429.         self.assertEqual(selected.values.tolist(), [[4, 1, 7, 4], [5, 2, 8, 5], [6, 3, 9, 6]])

  1430. 

  1431.         self.assertEqual(utils.to_json_structure(selected.metadata.to_internal_simple_structure()), [{

  1432.             'selector': [],

  1433.             'metadata': {

  1434.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1435.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1436.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1437.                 'dimension': {

  1438.                     'name': 'rows',

  1439.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1440.                     'length': 3,

  1441.                 },

  1442.             },

  1443.         }, {

  1444.             'selector': ['__ALL_ELEMENTS__'],

  1445.             'metadata': {

  1446.                 'dimension': {

  1447.                     'name': 'columns',

  1448.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1449.                     'length': 4,

  1450.                 },

  1451.             },

  1452.         }, {

  1453.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1454.             'metadata': {'structural_type': 'numpy.int64'},

  1455.         }, {

  1456.             'selector': ['__ALL_ELEMENTS__', 0],

  1457.             'metadata': {'name': 'bbb'},

  1458.         }, {

  1459.             'selector': ['__ALL_ELEMENTS__', 1],

  1460.             'metadata': {'name': 'aaa'},

  1461.         }, {

  1462.             'selector': ['__ALL_ELEMENTS__', 2],

  1463.             'metadata': {'name': 'ccc'},

  1464.         }, {

  1465.             'selector': ['__ALL_ELEMENTS__', 3],

  1466.             'metadata': {'name': 'bbb'},

  1467.         }, {

  1468.             'selector': [0, '__ALL_ELEMENTS__'],

  1469.             'metadata': {'all_elements_on_row': 'rowA'},

  1470.         }, {

  1471.             'selector': [0, 1],

  1472.             'metadata': {'row': '1'},

  1473.         }, {

  1474.             'selector': [1, 1],

  1475.             'metadata': {'row': '2'},

  1476.         }, {

  1477.             'selector': [2, 1],

  1478.             'metadata': {'row': '3'},

  1479.         }])

  1480. 

  1481.         self.assertEqual(data.metadata.to_internal_json_structure(), data_metadata_before)

  1482. 

  1483.         selected = data.select_columns([1])

  1484. 

  1485.         self.assertEqual(selected.values.tolist(), [[4], [5], [6]])

  1486. 

  1487.         self.assertEqual(utils.to_json_structure(selected.metadata.to_internal_simple_structure()), [{

  1488.             'selector': [],

  1489.             'metadata': {

  1490.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1491.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1492.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1493.                 'dimension': {

  1494.                     'name': 'rows',

  1495.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1496.                     'length': 3,

  1497.                 },

  1498.             },

  1499.         }, {

  1500.             'selector': ['__ALL_ELEMENTS__'],

  1501.             'metadata': {

  1502.                 'dimension': {

  1503.                     'name': 'columns',

  1504.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1505.                     'length': 1,

  1506.                 },

  1507.             },

  1508.         }, {

  1509.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1510.             'metadata': {'structural_type': 'numpy.int64'},

  1511.         }, {

  1512.             'selector': ['__ALL_ELEMENTS__', 0],

  1513.             'metadata': {'name': 'bbb'},

  1514.         }, {

  1515.             'selector': [0, '__ALL_ELEMENTS__'],

  1516.             'metadata': {'all_elements_on_row': 'rowA'},

  1517.         }])

  1518. 

  1519.         self.assertEqual(data.metadata.to_internal_json_structure(), data_metadata_before)

  1520. 

  1521.     def test_select_columns_noncompact_metadata(self):

  1522.         data = container.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]}, generate_metadata=False)

  1523. 

  1524.         data.metadata = data.metadata.generate(data, compact=False)

  1525. 

  1526.         data.metadata = data.metadata.update_column(0, {'name': 'aaa'})

  1527.         data.metadata = data.metadata.update_column(1, {'name': 'bbb'})

  1528.         data.metadata = data.metadata.update_column(2, {'name': 'ccc'})

  1529.         data.metadata = data.metadata.update((0, 0), {'row': '1'})

  1530.         data.metadata = data.metadata.update((1, 0), {'row': '2'})

  1531.         data.metadata = data.metadata.update((2, 0), {'row': '3'})

  1532.         data.metadata = data.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  1533. 

  1534.         data_metadata_before = data.metadata.to_internal_json_structure()

  1535. 

  1536.         # Test "select_columns" working with a tuple. Specifically, iloc[:, tuple(1)] does not work

  1537.         # (i.e. throws "{IndexingError}Too many indexers"), but iloc[:, 1] and iloc[:, [1]] work.

  1538.         selected = data.select_columns(tuple([1, 0, 2, 1]))

  1539. 

  1540.         self.assertEqual(selected.values.tolist(), [[4, 1, 7, 4], [5, 2, 8, 5], [6, 3, 9, 6]])

  1541. 

  1542.         self.assertEqual(utils.to_json_structure(selected.metadata.to_internal_simple_structure()), [{

  1543.             'selector': [],

  1544.             'metadata': {

  1545.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1546.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1547.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1548.                 'dimension': {

  1549.                     'name': 'rows',

  1550.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1551.                     'length': 3,

  1552.                 },

  1553.             },

  1554.         }, {

  1555.             'selector': ['__ALL_ELEMENTS__'],

  1556.             'metadata': {

  1557.                 'dimension': {

  1558.                     'name': 'columns',

  1559.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1560.                     'length': 4,

  1561.                 },

  1562.             },

  1563.         }, {

  1564.             'selector': ['__ALL_ELEMENTS__', 0],

  1565.             'metadata': {'name': 'bbb', 'structural_type': 'numpy.int64'},

  1566.         }, {

  1567.             'selector': ['__ALL_ELEMENTS__', 1],

  1568.             'metadata': {'name': 'aaa', 'structural_type': 'numpy.int64'},

  1569.         }, {

  1570.             'selector': ['__ALL_ELEMENTS__', 2],

  1571.             'metadata': {'name': 'ccc', 'structural_type': 'numpy.int64'},

  1572.         }, {

  1573.             'selector': ['__ALL_ELEMENTS__', 3],

  1574.             'metadata': {'name': 'bbb', 'structural_type': 'numpy.int64'},

  1575.         }, {

  1576.             'selector': [0, '__ALL_ELEMENTS__'],

  1577.             'metadata': {'all_elements_on_row': 'rowA'},

  1578.         }, {

  1579.             'selector': [0, 1],

  1580.             'metadata': {'row': '1'},

  1581.         }, {

  1582.             'selector': [1, 1],

  1583.             'metadata': {'row': '2'},

  1584.         }, {

  1585.             'selector': [2, 1],

  1586.             'metadata': {'row': '3'},

  1587.         }])

  1588. 

  1589.         self.assertEqual(data.metadata.to_internal_json_structure(), data_metadata_before)

  1590. 

  1591.         selected = data.select_columns([1])

  1592. 

  1593.         self.assertEqual(selected.values.tolist(), [[4], [5], [6]])

  1594. 

  1595.         self.assertEqual(utils.to_json_structure(selected.metadata.to_internal_simple_structure()), [{

  1596.             'selector': [],

  1597.             'metadata': {

  1598.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1599.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1600.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1601.                 'dimension': {

  1602.                     'name': 'rows',

  1603.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1604.                     'length': 3,

  1605.                 },

  1606.             },

  1607.         }, {

  1608.             'selector': ['__ALL_ELEMENTS__'],

  1609.             'metadata': {

  1610.                 'dimension': {

  1611.                     'name': 'columns',

  1612.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1613.                     'length': 1,

  1614.                 },

  1615.             },

  1616.         }, {

  1617.             'selector': ['__ALL_ELEMENTS__', 0],

  1618.             'metadata': {'name': 'bbb', 'structural_type': 'numpy.int64'},

  1619.         }, {

  1620.             'selector': [0, '__ALL_ELEMENTS__'],

  1621.             'metadata': {'all_elements_on_row': 'rowA'},

  1622.         }])

  1623. 

  1624.         self.assertEqual(data.metadata.to_internal_json_structure(), data_metadata_before)

  1625. 

  1626.     def test_append_columns_compact_metadata(self):

  1627.         left = container.DataFrame({'a1': [1, 2, 3], 'b1': [4, 5, 6], 'c1': [7, 8, 9]}, {

  1628.             'top_level': 'left',

  1629.         }, generate_metadata=False)

  1630.         left.metadata = left.metadata.generate(left, compact=True)

  1631. 

  1632.         left.metadata = left.metadata.update_column(0, {'name': 'aaa111'})

  1633.         left.metadata = left.metadata.update_column(1, {'name': 'bbb111'})

  1634.         left.metadata = left.metadata.update_column(2, {'name': 'ccc111'})

  1635.         left.metadata = left.metadata.update((0, 0), {'row': '1a'})

  1636.         left.metadata = left.metadata.update((1, 0), {'row': '2a'})

  1637.         left.metadata = left.metadata.update((2, 0), {'row': '3a'})

  1638.         left.metadata = left.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  1639. 

  1640.         right = container.DataFrame({'a2': [11, 12, 13], 'b2': [14, 15, 16], 'c2': [17, 18, 19]}, {

  1641.             'top_level': 'right',

  1642.         }, generate_metadata=False)

  1643.         right.metadata = right.metadata.generate(right, compact=True)

  1644. 

  1645.         right.metadata = right.metadata.update_column(0, {'name': 'aaa222'})

  1646.         right.metadata = right.metadata.update_column(1, {'name': 'bbb222'})

  1647.         right.metadata = right.metadata.update_column(2, {'name': 'ccc222'})

  1648.         right.metadata = right.metadata.update((0, 1), {'row': '1b'})

  1649.         right.metadata = right.metadata.update((1, 1), {'row': '2b'})

  1650.         right.metadata = right.metadata.update((2, 1), {'row': '3b'})

  1651.         right.metadata = right.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowB'})

  1652. 

  1653.         right_metadata_before = right.metadata.to_internal_json_structure()

  1654. 

  1655.         data = left.append_columns(right, use_right_metadata=False)

  1656. 

  1657.         self.assertEqual(data.values.tolist(), [[1, 4, 7, 11, 14, 17], [2, 5, 8, 12, 15, 18], [3, 6, 9, 13, 16, 19]])

  1658. 

  1659.         self.assertEqual(utils.to_json_structure(data.metadata.to_internal_simple_structure()), [{

  1660.             'selector': [],

  1661.             'metadata': {

  1662.                 'top_level': 'left',

  1663.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1664.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1665.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1666.                 'dimension': {

  1667.                     'name': 'rows',

  1668.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1669.                     'length': 3,

  1670.                 },

  1671.             },

  1672.         }, {

  1673.             'selector': ['__ALL_ELEMENTS__'],

  1674.             'metadata': {

  1675.                 'dimension': {

  1676.                     'name': 'columns',

  1677.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1678.                     'length': 6,

  1679.                 },

  1680.             },

  1681.         }, {

  1682.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1683.             'metadata': {

  1684.                 'structural_type': 'numpy.int64',

  1685.             },

  1686.         }, {

  1687.             'selector': ['__ALL_ELEMENTS__', 0],

  1688.             'metadata': {'name': 'aaa111'},

  1689.         }, {

  1690.             'selector': ['__ALL_ELEMENTS__', 1],

  1691.             'metadata': {'name': 'bbb111'},

  1692.         }, {

  1693.             'selector': ['__ALL_ELEMENTS__', 2],

  1694.             'metadata': {'name': 'ccc111'},

  1695.         }, {

  1696.             'selector': ['__ALL_ELEMENTS__', 3],

  1697.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  1698.         }, {

  1699.             'selector': ['__ALL_ELEMENTS__', 4],

  1700.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  1701.         }, {

  1702.             'selector': ['__ALL_ELEMENTS__', 5],

  1703.             'metadata': {'name': 'ccc222', 'structural_type': 'numpy.int64'},

  1704.         }, {

  1705.             'selector': [0, '__ALL_ELEMENTS__'],

  1706.             'metadata': {'all_elements_on_row': 'rowA'},

  1707.         }, {

  1708.             'selector': [0, 0],

  1709.             'metadata': {'row': '1a'},

  1710.         }, {

  1711.             'selector': [0, 3],

  1712.             'metadata': {'all_elements_on_row': 'rowB'},

  1713.         }, {

  1714.             'selector': [0, 4],

  1715.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  1716.         }, {

  1717.             'selector': [0, 5],

  1718.             'metadata': {'all_elements_on_row': 'rowB'},

  1719.         }, {

  1720.             'selector': [1, 0],

  1721.             'metadata': {'row': '2a'},

  1722.         }, {

  1723.             'selector': [1, 4],

  1724.             'metadata': {'row': '2b'},

  1725.         }, {

  1726.             'selector': [2, 0],

  1727.             'metadata': {'row': '3a'},

  1728.         }, {

  1729.             'selector': [2, 4],

  1730.             'metadata': {'row': '3b'},

  1731.         }])

  1732. 

  1733.         data = left.append_columns(right, use_right_metadata=True)

  1734. 

  1735.         self.assertEqual(data.values.tolist(), [[1, 4, 7, 11, 14, 17], [2, 5, 8, 12, 15, 18], [3, 6, 9, 13, 16, 19]])

  1736. 

  1737.         self.assertEqual(utils.to_json_structure(data.metadata.to_internal_simple_structure()), [{

  1738.             'selector': [],

  1739.             'metadata': {

  1740.                 'top_level': 'right',

  1741.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1742.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1743.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1744.                 'dimension': {

  1745.                     'name': 'rows',

  1746.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1747.                     'length': 3,

  1748.                 },

  1749.             },

  1750.         }, {

  1751.             'selector': ['__ALL_ELEMENTS__'],

  1752.             'metadata': {

  1753.                 'dimension': {

  1754.                     'name': 'columns',

  1755.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1756.                     'length': 6,

  1757.                 },

  1758.             },

  1759.         }, {

  1760.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  1761.             'metadata': {

  1762.                 'structural_type': 'numpy.int64',

  1763.             },

  1764.         }, {

  1765.             'selector': ['__ALL_ELEMENTS__', 0],

  1766.             'metadata': {'name': 'aaa111', 'structural_type': 'numpy.int64'},

  1767.         }, {

  1768.             'selector': ['__ALL_ELEMENTS__', 1],

  1769.             'metadata': {'name': 'bbb111', 'structural_type': 'numpy.int64'},

  1770.         }, {

  1771.             'selector': ['__ALL_ELEMENTS__', 2],

  1772.             'metadata': {'name': 'ccc111', 'structural_type': 'numpy.int64'},

  1773.         }, {

  1774.             'selector': ['__ALL_ELEMENTS__', 3],

  1775.             'metadata': {'name': 'aaa222'},

  1776.         }, {

  1777.             'selector': ['__ALL_ELEMENTS__', 4],

  1778.             'metadata': {'name': 'bbb222'},

  1779.         }, {

  1780.             'selector': ['__ALL_ELEMENTS__', 5],

  1781.             'metadata': {'name': 'ccc222'},

  1782.         }, {

  1783.             'selector': [0, '__ALL_ELEMENTS__'],

  1784.             'metadata': {'all_elements_on_row': 'rowB'},

  1785.         }, {

  1786.             'selector': [0, 0],

  1787.             'metadata': {'row': '1a', 'all_elements_on_row': 'rowA'},

  1788.         }, {

  1789.             'selector': [0, 1],

  1790.             'metadata': {'all_elements_on_row': 'rowA'},

  1791.         }, {

  1792.             'selector': [0, 2],

  1793.             'metadata': {'all_elements_on_row': 'rowA'},

  1794.         }, {

  1795.             'selector': [0, 4],

  1796.             'metadata': {'row': '1b'},

  1797.         }, {

  1798.             'selector': [1, 0],

  1799.             'metadata': {'row': '2a'},

  1800.         }, {

  1801.             'selector': [1, 4],

  1802.             'metadata': {'row': '2b'},

  1803.         }, {

  1804.             'selector': [2, 0],

  1805.             'metadata': {'row': '3a'},

  1806.         }, {

  1807.             'selector': [2, 4],

  1808.             'metadata': {'row': '3b'},

  1809.         }])

  1810. 

  1811.         self.assertEqual(right.metadata.to_internal_json_structure(), right_metadata_before)

  1812. 

  1813.     def test_append_columns_noncompact_metadata(self):

  1814.         left = container.DataFrame({'a1': [1, 2, 3], 'b1': [4, 5, 6], 'c1': [7, 8, 9]}, {

  1815.             'top_level': 'left',

  1816.         }, generate_metadata=False)

  1817.         left.metadata = left.metadata.generate(left, compact=False)

  1818. 

  1819.         left.metadata = left.metadata.update_column(0, {'name': 'aaa111'})

  1820.         left.metadata = left.metadata.update_column(1, {'name': 'bbb111'})

  1821.         left.metadata = left.metadata.update_column(2, {'name': 'ccc111'})

  1822.         left.metadata = left.metadata.update((0, 0), {'row': '1a'})

  1823.         left.metadata = left.metadata.update((1, 0), {'row': '2a'})

  1824.         left.metadata = left.metadata.update((2, 0), {'row': '3a'})

  1825.         left.metadata = left.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  1826. 

  1827.         right = container.DataFrame({'a2': [11, 12, 13], 'b2': [14, 15, 16], 'c2': [17, 18, 19]}, {

  1828.             'top_level': 'right',

  1829.         }, generate_metadata=False)

  1830.         right.metadata = right.metadata.generate(right, compact=False)

  1831. 

  1832.         right.metadata = right.metadata.update_column(0, {'name': 'aaa222'})

  1833.         right.metadata = right.metadata.update_column(1, {'name': 'bbb222'})

  1834.         right.metadata = right.metadata.update_column(2, {'name': 'ccc222'})

  1835.         right.metadata = right.metadata.update((0, 1), {'row': '1b'})

  1836.         right.metadata = right.metadata.update((1, 1), {'row': '2b'})

  1837.         right.metadata = right.metadata.update((2, 1), {'row': '3b'})

  1838.         right.metadata = right.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowB'})

  1839. 

  1840.         right_metadata_before = right.metadata.to_internal_json_structure()

  1841. 

  1842.         data = left.append_columns(right, use_right_metadata=False)

  1843. 

  1844.         self.assertEqual(data.values.tolist(), [[1, 4, 7, 11, 14, 17], [2, 5, 8, 12, 15, 18], [3, 6, 9, 13, 16, 19]])

  1845. 

  1846.         self.assertEqual(utils.to_json_structure(data.metadata.to_internal_simple_structure()), [{

  1847.             'selector': [],

  1848.             'metadata': {

  1849.                 'top_level': 'left',

  1850.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1851.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1852.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1853.                 'dimension': {

  1854.                     'name': 'rows',

  1855.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1856.                     'length': 3,

  1857.                 },

  1858.             },

  1859.         }, {

  1860.             'selector': ['__ALL_ELEMENTS__'],

  1861.             'metadata': {

  1862.                 'dimension': {

  1863.                     'name': 'columns',

  1864.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1865.                     'length': 6,

  1866.                 },

  1867.             },

  1868.         }, {

  1869.             'selector': ['__ALL_ELEMENTS__', 0],

  1870.             'metadata': {'name': 'aaa111', 'structural_type': 'numpy.int64'},

  1871.         }, {

  1872.             'selector': ['__ALL_ELEMENTS__', 1],

  1873.             'metadata': {'name': 'bbb111', 'structural_type': 'numpy.int64'},

  1874.         }, {

  1875.             'selector': ['__ALL_ELEMENTS__', 2],

  1876.             'metadata': {'name': 'ccc111', 'structural_type': 'numpy.int64'},

  1877.         }, {

  1878.             'selector': ['__ALL_ELEMENTS__', 3],

  1879.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  1880.         }, {

  1881.             'selector': ['__ALL_ELEMENTS__', 4],

  1882.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  1883.         }, {

  1884.             'selector': ['__ALL_ELEMENTS__', 5],

  1885.             'metadata': {'name': 'ccc222', 'structural_type': 'numpy.int64'},

  1886.         }, {

  1887.             'selector': [0, '__ALL_ELEMENTS__'],

  1888.             'metadata': {'all_elements_on_row': 'rowA'},

  1889.         }, {

  1890.             'selector': [0, 0],

  1891.             'metadata': {'row': '1a'},

  1892.         }, {

  1893.             'selector': [0, 3],

  1894.             'metadata': {'all_elements_on_row': 'rowB'},

  1895.         }, {

  1896.             'selector': [0, 4],

  1897.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  1898.         }, {

  1899.             'selector': [0, 5],

  1900.             'metadata': {'all_elements_on_row': 'rowB'},

  1901.         }, {

  1902.             'selector': [1, 0],

  1903.             'metadata': {'row': '2a'},

  1904.         }, {

  1905.             'selector': [1, 4],

  1906.             'metadata': {'row': '2b'},

  1907.         }, {

  1908.             'selector': [2, 0],

  1909.             'metadata': {'row': '3a'},

  1910.         }, {

  1911.             'selector': [2, 4],

  1912.             'metadata': {'row': '3b'},

  1913.         }])

  1914. 

  1915.         data = left.append_columns(right, use_right_metadata=True)

  1916. 

  1917.         self.assertEqual(data.values.tolist(), [[1, 4, 7, 11, 14, 17], [2, 5, 8, 12, 15, 18], [3, 6, 9, 13, 16, 19]])

  1918. 

  1919.         self.assertEqual(utils.to_json_structure(data.metadata.to_internal_simple_structure()), [{

  1920.             'selector': [],

  1921.             'metadata': {

  1922.                 'top_level': 'right',

  1923.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  1924.                 'structural_type': 'd3m.container.pandas.DataFrame',

  1925.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  1926.                 'dimension': {

  1927.                     'name': 'rows',

  1928.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  1929.                     'length': 3,

  1930.                 },

  1931.             },

  1932.         }, {

  1933.             'selector': ['__ALL_ELEMENTS__'],

  1934.             'metadata': {

  1935.                 'dimension': {

  1936.                     'name': 'columns',

  1937.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  1938.                     'length': 6,

  1939.                 },

  1940.             },

  1941.         }, {

  1942.             'selector': ['__ALL_ELEMENTS__', 0],

  1943.             'metadata': {'name': 'aaa111', 'structural_type': 'numpy.int64'},

  1944.         }, {

  1945.             'selector': ['__ALL_ELEMENTS__', 1],

  1946.             'metadata': {'name': 'bbb111', 'structural_type': 'numpy.int64'},

  1947.         }, {

  1948.             'selector': ['__ALL_ELEMENTS__', 2],

  1949.             'metadata': {'name': 'ccc111', 'structural_type': 'numpy.int64'},

  1950.         }, {

  1951.             'selector': ['__ALL_ELEMENTS__', 3],

  1952.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  1953.         }, {

  1954.             'selector': ['__ALL_ELEMENTS__', 4],

  1955.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  1956.         }, {

  1957.             'selector': ['__ALL_ELEMENTS__', 5],

  1958.             'metadata': {'name': 'ccc222', 'structural_type': 'numpy.int64'},

  1959.         }, {

  1960.             'selector': [0, '__ALL_ELEMENTS__'],

  1961.             'metadata': {'all_elements_on_row': 'rowB'},

  1962.         }, {

  1963.             'selector': [0, 0],

  1964.             'metadata': {'row': '1a', 'all_elements_on_row': 'rowA'},

  1965.         }, {

  1966.             'selector': [0, 1],

  1967.             'metadata': {'all_elements_on_row': 'rowA'},

  1968.         }, {

  1969.             'selector': [0, 2],

  1970.             'metadata': {'all_elements_on_row': 'rowA'},

  1971.         }, {

  1972.             'selector': [0, 4],

  1973.             'metadata': {'row': '1b'},

  1974.         }, {

  1975.             'selector': [1, 0],

  1976.             'metadata': {'row': '2a'},

  1977.         }, {

  1978.             'selector': [1, 4],

  1979.             'metadata': {'row': '2b'},

  1980.         }, {

  1981.             'selector': [2, 0],

  1982.             'metadata': {'row': '3a'},

  1983.         }, {

  1984.             'selector': [2, 4],

  1985.             'metadata': {'row': '3b'},

  1986.         }])

  1987. 

  1988.         self.assertEqual(right.metadata.to_internal_json_structure(), right_metadata_before)

  1989. 

  1990.     def test_replace_columns_compact_metadata(self):

  1991.         main = container.DataFrame({'a1': [1, 2, 3], 'b1': [4, 5, 6], 'c1': [7, 8, 9]}, {

  1992.             'top_level': 'main',

  1993.         }, generate_metadata=False)

  1994.         main.metadata = main.metadata.generate(main, compact=True)

  1995. 

  1996.         main.metadata = main.metadata.update_column(0, {'name': 'aaa111'})

  1997.         main.metadata = main.metadata.update_column(1, {'name': 'bbb111', 'extra': 'b_column'})

  1998.         main.metadata = main.metadata.update_column(2, {'name': 'ccc111'})

  1999.         main.metadata = main.metadata.update((0, 0), {'row': '1a'})

  2000.         main.metadata = main.metadata.update((1, 0), {'row': '2a'})

  2001.         main.metadata = main.metadata.update((2, 0), {'row': '3a'})

  2002.         main.metadata = main.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  2003. 

  2004.         main_metadata_before = main.metadata.to_internal_json_structure()

  2005. 

  2006.         columns = container.DataFrame({'a2': [11, 12, 13], 'b2': [14, 15, 16]}, {

  2007.             'top_level': 'columns',

  2008.         }, generate_metadata=False)

  2009.         columns.metadata = columns.metadata.generate(columns, compact=True)

  2010. 

  2011.         columns.metadata = columns.metadata.update_column(0, {'name': 'aaa222'})

  2012.         columns.metadata = columns.metadata.update_column(1, {'name': 'bbb222'})

  2013.         columns.metadata = columns.metadata.update((0, 1), {'row': '1b'})

  2014.         columns.metadata = columns.metadata.update((1, 1), {'row': '2b'})

  2015.         columns.metadata = columns.metadata.update((2, 1), {'row': '3b'})

  2016.         columns.metadata = columns.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowB'})

  2017. 

  2018.         columns_metadata_before = columns.metadata.to_internal_json_structure()

  2019. 

  2020.         new_main = main.replace_columns(columns, [1, 2])

  2021. 

  2022.         self.assertEqual(new_main.values.tolist(), [[1, 11, 14], [2, 12, 15], [3, 13, 16]])

  2023. 

  2024.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2025.             'selector': [], 'metadata': {

  2026.                 'top_level': 'main',

  2027.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2028.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2029.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2030.                 'dimension': {

  2031.                     'name': 'rows',

  2032.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2033.                     'length': 3,

  2034.                 },

  2035.             },

  2036.         }, {

  2037.             'selector': ['__ALL_ELEMENTS__'],

  2038.             'metadata': {

  2039.                 'dimension': {

  2040.                     'name': 'columns',

  2041.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2042.                     'length': 3,

  2043.                 },

  2044.             },

  2045.         }, {

  2046.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  2047.             'metadata': {

  2048.                 'structural_type': 'numpy.int64',

  2049.             },

  2050.         }, {

  2051.             'selector': ['__ALL_ELEMENTS__', 0],

  2052.             'metadata': {'name': 'aaa111'},

  2053.         }, {

  2054.             'selector': ['__ALL_ELEMENTS__', 1],

  2055.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2056.         }, {

  2057.             'selector': ['__ALL_ELEMENTS__', 2],

  2058.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2059.         }, {

  2060.             'selector': [0, '__ALL_ELEMENTS__'],

  2061.             'metadata': {'all_elements_on_row': 'rowA'},

  2062.         }, {

  2063.             'selector': [0, 0],

  2064.             'metadata': {'row': '1a'},

  2065.         }, {

  2066.             'selector': [0, 1],

  2067.             'metadata': {'all_elements_on_row': 'rowB'},

  2068.         }, {

  2069.             'selector': [0, 2],

  2070.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2071.         }, {

  2072.             'selector': [1, 0],

  2073.             'metadata': {'row': '2a'},

  2074.         }, {

  2075.             'selector': [1, 2],

  2076.             'metadata': {'row': '2b'},

  2077.         }, {

  2078.             'selector': [2, 0],

  2079.             'metadata': {'row': '3a'},

  2080.         }, {

  2081.             'selector': [2, 2],

  2082.             'metadata': {'row': '3b'},

  2083.         }])

  2084. 

  2085.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2086.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2087. 

  2088.         new_main = main.replace_columns(columns, [0, 2])

  2089. 

  2090.         self.assertEqual(new_main.values.tolist(), [[11, 4, 14], [12, 5, 15], [13, 6, 16]])

  2091. 

  2092.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2093.             'selector': [], 'metadata': {

  2094.                 'top_level': 'main',

  2095.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2096.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2097.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2098.                 'dimension': {

  2099.                     'name': 'rows',

  2100.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2101.                     'length': 3,

  2102.                 },

  2103.             },

  2104.         }, {

  2105.             'selector': ['__ALL_ELEMENTS__'],

  2106.             'metadata': {

  2107.                 'dimension': {

  2108.                     'name': 'columns',

  2109.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2110.                     'length': 3,

  2111.                 },

  2112.             },

  2113.         }, {

  2114.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  2115.             'metadata': {

  2116.                 'structural_type': 'numpy.int64',

  2117.             },

  2118.         }, {

  2119.             'selector': ['__ALL_ELEMENTS__', 0],

  2120.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2121.         }, {

  2122.             'selector': ['__ALL_ELEMENTS__', 1],

  2123.             'metadata': {

  2124.                 'name': 'bbb111',

  2125.                 'extra': 'b_column',

  2126.             },

  2127.         }, {

  2128.             'selector': ['__ALL_ELEMENTS__', 2],

  2129.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2130.         }, {

  2131.             'selector': [0, '__ALL_ELEMENTS__'],

  2132.             'metadata': {'all_elements_on_row': 'rowA'},

  2133.         }, {

  2134.             'selector': [0, 0],

  2135.             'metadata': {'all_elements_on_row': 'rowB'},

  2136.         }, {

  2137.             'selector': [0, 2],

  2138.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2139.         }, {

  2140.             'selector': [1, 2],

  2141.             'metadata': {'row': '2b'},

  2142.         }, {

  2143.             'selector': [2, 2],

  2144.             'metadata': {'row': '3b'},

  2145.         }])

  2146. 

  2147.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2148.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2149. 

  2150.         new_main = main.replace_columns(columns, [1])

  2151. 

  2152.         self.assertEqual(new_main.values.tolist(), [[1, 11, 14, 7], [2, 12, 15, 8], [3, 13, 16, 9]])

  2153. 

  2154.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2155.             'selector': [], 'metadata': {

  2156.                 'top_level': 'main',

  2157.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2158.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2159.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2160.                 'dimension': {

  2161.                     'name': 'rows',

  2162.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2163.                     'length': 3,

  2164.                 },

  2165.             },

  2166.         }, {

  2167.             'selector': ['__ALL_ELEMENTS__'],

  2168.             'metadata': {

  2169.                 'dimension': {

  2170.                     'name': 'columns',

  2171.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2172.                     'length': 4,

  2173.                 },

  2174.             },

  2175.         }, {

  2176.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  2177.             'metadata': {

  2178.                 'structural_type': 'numpy.int64',

  2179.             },

  2180.         }, {

  2181.             'selector': ['__ALL_ELEMENTS__', 0],

  2182.             'metadata': {'name': 'aaa111'},

  2183.         }, {

  2184.             'selector': ['__ALL_ELEMENTS__', 1],

  2185.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2186.         }, {

  2187.             'selector': ['__ALL_ELEMENTS__', 2],

  2188.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2189.         }, {

  2190.             'selector': ['__ALL_ELEMENTS__', 3],

  2191.             'metadata': {'name': 'ccc111', 'structural_type': 'numpy.int64'},

  2192.         }, {

  2193.             'selector': [0, '__ALL_ELEMENTS__'],

  2194.             'metadata': {'all_elements_on_row': 'rowA'},

  2195.         }, {

  2196.             'selector': [0, 0],

  2197.             'metadata': {'row': '1a'},

  2198.         }, {

  2199.             'selector': [0, 1],

  2200.             'metadata': {'all_elements_on_row': 'rowB'},

  2201.         }, {

  2202.             'selector': [0, 2],

  2203.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2204.         }, {

  2205.             'selector': [0, 3],

  2206.             'metadata': {'all_elements_on_row': 'rowA'},

  2207.         }, {

  2208.             'selector': [1, 0],

  2209.             'metadata': {'row': '2a'},

  2210.         }, {

  2211.             'selector': [1, 2],

  2212.             'metadata': {'row': '2b'},

  2213.         }, {

  2214.             'selector': [2, 0],

  2215.             'metadata': {'row': '3a'},

  2216.         }, {

  2217.             'selector': [2, 2],

  2218.             'metadata': {'row': '3b'},

  2219.         }])

  2220. 

  2221.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2222.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2223. 

  2224.         new_main = main.replace_columns(columns, [0, 1, 2])

  2225. 

  2226.         self.assertEqual(new_main.values.tolist(), [[11, 14], [12, 15], [13, 16]])

  2227. 

  2228.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2229.             'selector': [], 'metadata': {

  2230.                 'top_level': 'main',

  2231.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2232.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2233.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2234.                 'dimension': {

  2235.                     'name': 'rows',

  2236.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2237.                     'length': 3,

  2238.                 },

  2239.             },

  2240.         }, {

  2241.             'selector': ['__ALL_ELEMENTS__'],

  2242.             'metadata': {

  2243.                 'dimension': {

  2244.                     'name': 'columns',

  2245.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2246.                     'length': 2,

  2247.                 },

  2248.             },

  2249.         }, {

  2250.             'selector': ['__ALL_ELEMENTS__', '__ALL_ELEMENTS__'],

  2251.             'metadata': {

  2252.                 'structural_type': 'numpy.int64',

  2253.             },

  2254.         }, {

  2255.             'selector': ['__ALL_ELEMENTS__', 0],

  2256.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2257.         }, {

  2258.             'selector': ['__ALL_ELEMENTS__', 1],

  2259.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2260.         }, {

  2261.             'selector': [0, '__ALL_ELEMENTS__'],

  2262.             'metadata': {'all_elements_on_row': 'rowA'},

  2263.         }, {

  2264.             'selector': [0, 0],

  2265.             'metadata': {'all_elements_on_row': 'rowB'},

  2266.         }, {

  2267.             'selector': [0, 1],

  2268.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2269.         }, {

  2270.             'selector': [1, 1],

  2271.             'metadata': {'row': '2b'},

  2272.         }, {

  2273.             'selector': [2, 1],

  2274.             'metadata': {'row': '3b'},

  2275.         }])

  2276. 

  2277.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2278.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2279. 

  2280.     def test_replace_columns_noncompact_metadata(self):

  2281.         main = container.DataFrame({'a1': [1, 2, 3], 'b1': [4, 5, 6], 'c1': [7, 8, 9]}, {

  2282.             'top_level': 'main',

  2283.         }, generate_metadata=False)

  2284.         main.metadata = main.metadata.generate(main, compact=False)

  2285. 

  2286.         main.metadata = main.metadata.update_column(0, {'name': 'aaa111'})

  2287.         main.metadata = main.metadata.update_column(1, {'name': 'bbb111', 'extra': 'b_column'})

  2288.         main.metadata = main.metadata.update_column(2, {'name': 'ccc111'})

  2289.         main.metadata = main.metadata.update((0, 0), {'row': '1a'})

  2290.         main.metadata = main.metadata.update((1, 0), {'row': '2a'})

  2291.         main.metadata = main.metadata.update((2, 0), {'row': '3a'})

  2292.         main.metadata = main.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowA'})

  2293. 

  2294.         main_metadata_before = main.metadata.to_internal_json_structure()

  2295. 

  2296.         columns = container.DataFrame({'a2': [11, 12, 13], 'b2': [14, 15, 16]}, {

  2297.             'top_level': 'columns',

  2298.         }, generate_metadata=False)

  2299.         columns.metadata = columns.metadata.generate(columns, compact=False)

  2300. 

  2301.         columns.metadata = columns.metadata.update_column(0, {'name': 'aaa222'})

  2302.         columns.metadata = columns.metadata.update_column(1, {'name': 'bbb222'})

  2303.         columns.metadata = columns.metadata.update((0, 1), {'row': '1b'})

  2304.         columns.metadata = columns.metadata.update((1, 1), {'row': '2b'})

  2305.         columns.metadata = columns.metadata.update((2, 1), {'row': '3b'})

  2306.         columns.metadata = columns.metadata.update((0, metadata_base.ALL_ELEMENTS), {'all_elements_on_row': 'rowB'})

  2307. 

  2308.         columns_metadata_before = columns.metadata.to_internal_json_structure()

  2309. 

  2310.         new_main = main.replace_columns(columns, [1, 2])

  2311. 

  2312.         self.assertEqual(new_main.values.tolist(), [[1, 11, 14], [2, 12, 15], [3, 13, 16]])

  2313. 

  2314.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2315.             'selector': [], 'metadata': {

  2316.                 'top_level': 'main',

  2317.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2318.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2319.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2320.                 'dimension': {

  2321.                     'name': 'rows',

  2322.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2323.                     'length': 3,

  2324.                 },

  2325.             },

  2326.         }, {

  2327.             'selector': ['__ALL_ELEMENTS__'],

  2328.             'metadata': {

  2329.                 'dimension': {

  2330.                     'name': 'columns',

  2331.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2332.                     'length': 3,

  2333.                 },

  2334.             },

  2335.         }, {

  2336.             'selector': ['__ALL_ELEMENTS__', 0],

  2337.             'metadata': {'name': 'aaa111', 'structural_type': 'numpy.int64'},

  2338.         }, {

  2339.             'selector': ['__ALL_ELEMENTS__', 1],

  2340.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2341.         }, {

  2342.             'selector': ['__ALL_ELEMENTS__', 2],

  2343.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2344.         }, {

  2345.             'selector': [0, '__ALL_ELEMENTS__'],

  2346.             'metadata': {'all_elements_on_row': 'rowA'},

  2347.         }, {

  2348.             'selector': [0, 0],

  2349.             'metadata': {'row': '1a'},

  2350.         }, {

  2351.             'selector': [0, 1],

  2352.             'metadata': {'all_elements_on_row': 'rowB'},

  2353.         }, {

  2354.             'selector': [0, 2],

  2355.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2356.         }, {

  2357.             'selector': [1, 0],

  2358.             'metadata': {'row': '2a'},

  2359.         }, {

  2360.             'selector': [1, 2],

  2361.             'metadata': {'row': '2b'},

  2362.         }, {

  2363.             'selector': [2, 0],

  2364.             'metadata': {'row': '3a'},

  2365.         }, {

  2366.             'selector': [2, 2],

  2367.             'metadata': {'row': '3b'},

  2368.         }])

  2369. 

  2370.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2371.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2372. 

  2373.         new_main = main.replace_columns(columns, [0, 2])

  2374. 

  2375.         self.assertEqual(new_main.values.tolist(), [[11, 4, 14], [12, 5, 15], [13, 6, 16]])

  2376. 

  2377.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2378.             'selector': [], 'metadata': {

  2379.                 'top_level': 'main',

  2380.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2381.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2382.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2383.                 'dimension': {

  2384.                     'name': 'rows',

  2385.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2386.                     'length': 3,

  2387.                 },

  2388.             },

  2389.         }, {

  2390.             'selector': ['__ALL_ELEMENTS__'],

  2391.             'metadata': {

  2392.                 'dimension': {

  2393.                     'name': 'columns',

  2394.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2395.                     'length': 3,

  2396.                 },

  2397.             },

  2398.         }, {

  2399.             'selector': ['__ALL_ELEMENTS__', 0],

  2400.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2401.         }, {

  2402.             'selector': ['__ALL_ELEMENTS__', 1],

  2403.             'metadata': {

  2404.                 'name': 'bbb111',

  2405.                 'extra': 'b_column',

  2406.                 'structural_type': 'numpy.int64',

  2407.             },

  2408.         }, {

  2409.             'selector': ['__ALL_ELEMENTS__', 2],

  2410.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2411.         }, {

  2412.             'selector': [0, '__ALL_ELEMENTS__'],

  2413.             'metadata': {'all_elements_on_row': 'rowA'},

  2414.         }, {

  2415.             'selector': [0, 0],

  2416.             'metadata': {'all_elements_on_row': 'rowB'},

  2417.         }, {

  2418.             'selector': [0, 2],

  2419.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2420.         }, {

  2421.             'selector': [1, 2],

  2422.             'metadata': {'row': '2b'},

  2423.         }, {

  2424.             'selector': [2, 2],

  2425.             'metadata': {'row': '3b'},

  2426.         }])

  2427. 

  2428.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2429.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2430. 

  2431.         new_main = main.replace_columns(columns, [1])

  2432. 

  2433.         self.assertEqual(new_main.values.tolist(), [[1, 11, 14, 7], [2, 12, 15, 8], [3, 13, 16, 9]])

  2434. 

  2435.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2436.             'selector': [], 'metadata': {

  2437.                 'top_level': 'main',

  2438.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2439.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2440.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2441.                 'dimension': {

  2442.                     'name': 'rows',

  2443.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2444.                     'length': 3,

  2445.                 },

  2446.             },

  2447.         }, {

  2448.             'selector': ['__ALL_ELEMENTS__'],

  2449.             'metadata': {

  2450.                 'dimension': {

  2451.                     'name': 'columns',

  2452.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2453.                     'length': 4,

  2454.                 },

  2455.             },

  2456.         }, {

  2457.             'selector': ['__ALL_ELEMENTS__', 0],

  2458.             'metadata': {'name': 'aaa111', 'structural_type': 'numpy.int64'},

  2459.         }, {

  2460.             'selector': ['__ALL_ELEMENTS__', 1],

  2461.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2462.         }, {

  2463.             'selector': ['__ALL_ELEMENTS__', 2],

  2464.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2465.         }, {

  2466.             'selector': ['__ALL_ELEMENTS__', 3],

  2467.             'metadata': {'name': 'ccc111', 'structural_type': 'numpy.int64'},

  2468.         }, {

  2469.             'selector': [0, '__ALL_ELEMENTS__'],

  2470.             'metadata': {'all_elements_on_row': 'rowA'},

  2471.         }, {

  2472.             'selector': [0, 0],

  2473.             'metadata': {'row': '1a'},

  2474.         }, {

  2475.             'selector': [0, 1],

  2476.             'metadata': {'all_elements_on_row': 'rowB'},

  2477.         }, {

  2478.             'selector': [0, 2],

  2479.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2480.         }, {

  2481.             'selector': [0, 3],

  2482.             'metadata': {'all_elements_on_row': 'rowA'},

  2483.         }, {

  2484.             'selector': [1, 0],

  2485.             'metadata': {'row': '2a'},

  2486.         }, {

  2487.             'selector': [1, 2],

  2488.             'metadata': {'row': '2b'},

  2489.         }, {

  2490.             'selector': [2, 0],

  2491.             'metadata': {'row': '3a'},

  2492.         }, {

  2493.             'selector': [2, 2],

  2494.             'metadata': {'row': '3b'},

  2495.         }])

  2496. 

  2497.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2498.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2499. 

  2500.         new_main = main.replace_columns(columns, [0, 1, 2])

  2501. 

  2502.         self.assertEqual(new_main.values.tolist(), [[11, 14], [12, 15], [13, 16]])

  2503. 

  2504.         self.assertEqual(utils.to_json_structure(new_main.metadata.to_internal_simple_structure()), [{

  2505.             'selector': [], 'metadata': {

  2506.                 'top_level': 'main',

  2507.                 'schema': metadata_base.CONTAINER_SCHEMA_VERSION,

  2508.                 'structural_type': 'd3m.container.pandas.DataFrame',

  2509.                 'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2510.                 'dimension': {

  2511.                     'name': 'rows',

  2512.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2513.                     'length': 3,

  2514.                 },

  2515.             },

  2516.         }, {

  2517.             'selector': ['__ALL_ELEMENTS__'],

  2518.             'metadata': {

  2519.                 'dimension': {

  2520.                     'name': 'columns',

  2521.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2522.                     'length': 2,

  2523.                 },

  2524.             },

  2525.         }, {

  2526.             'selector': ['__ALL_ELEMENTS__', 0],

  2527.             'metadata': {'name': 'aaa222', 'structural_type': 'numpy.int64'},

  2528.         }, {

  2529.             'selector': ['__ALL_ELEMENTS__', 1],

  2530.             'metadata': {'name': 'bbb222', 'structural_type': 'numpy.int64'},

  2531.         }, {

  2532.             'selector': [0, '__ALL_ELEMENTS__'],

  2533.             'metadata': {'all_elements_on_row': 'rowA'},

  2534.         }, {

  2535.             'selector': [0, 0],

  2536.             'metadata': {'all_elements_on_row': 'rowB'},

  2537.         }, {

  2538.             'selector': [0, 1],

  2539.             'metadata': {'row': '1b', 'all_elements_on_row': 'rowB'},

  2540.         }, {

  2541.             'selector': [1, 1],

  2542.             'metadata': {'row': '2b'},

  2543.         }, {

  2544.             'selector': [2, 1],

  2545.             'metadata': {'row': '3b'},

  2546.         }])

  2547. 

  2548.         self.assertEqual(main_metadata_before, main.metadata.to_internal_json_structure())

  2549.         self.assertEqual(columns_metadata_before, columns.metadata.to_internal_json_structure())

  2550. 

  2551.     def test_select_columns_empty(self):

  2552.         data = container.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6], 'c': [7, 8, 9]}, generate_metadata=True)

  2553. 

  2554.         with self.assertRaises(Exception):

  2555.             data.select_columns([])

  2556. 

  2557.         with self.assertRaises(Exception):

  2558.             data.metadata.select_columns([])

  2559. 

  2560.         selected = data.select_columns([], allow_empty_columns=True)

  2561. 

  2562.         self.assertEqual(selected.shape, (3, 0))

  2563. 

  2564.         self.assertEqual(utils.to_json_structure(selected.metadata.to_internal_simple_structure()), [{

  2565.             'selector': [],

  2566.             'metadata': {

  2567.                 'dimension': {

  2568.                     'length': 3,

  2569.                     'name': 'rows',

  2570.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularRow'],

  2571.                 },

  2572.                'schema': 'https://metadata.datadrivendiscovery.org/schemas/v0/container.json',

  2573.                'semantic_types': ['https://metadata.datadrivendiscovery.org/types/Table'],

  2574.                'structural_type': 'd3m.container.pandas.DataFrame',

  2575.             },

  2576.         }, {

  2577.             'selector': ['__ALL_ELEMENTS__'],

  2578.             'metadata': {

  2579.                 'dimension': {

  2580.                     'length': 0,

  2581.                     'name': 'columns',

  2582.                     'semantic_types': ['https://metadata.datadrivendiscovery.org/types/TabularColumn'],

  2583.                 },

  2584.             },

  2585.         }])

  2586. 

  2587.     def test_dataframe_select_copy(self):

  2588.         df = container.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})

  2589. 

  2590.         selection = df.select_columns([0])

  2591. 

  2592.         with warnings.catch_warnings(record=True) as w:

  2593.             selection.iloc[:, 0] = selection.iloc[:, 0].map(lambda x: x + 1)

  2594. 

  2595.         self.assertEqual(len(w), 0)

  2596. 

  2597.         self.assertEqual(selection.values.tolist(), [[2], [3], [4]])

  2598.         self.assertEqual(df.values.tolist(), [[1, 4], [2, 5], [3, 6]])

  2599. 

  2600.     def test_save_container_empty_dataset(self):

  2601.         dataset = container.Dataset({}, generate_metadata=True)

  2602. 

  2603.         with tempfile.TemporaryDirectory() as temp_directory:

  2604.             container_utils.save_container(dataset, os.path.join(temp_directory, 'dataset'))

  2605. 

  2606. 

  2607. if __name__ == '__main__':

  2608.     unittest.main()