def test_get_table_meta(self): """Test get table meta""" # Setup metadata = Mock(spec=Metadata) metadata._metadata = {'tables': {'test': {'some': 'data'}}} # Run result = Metadata.get_table_meta(metadata, 'test') # Asserts assert result == {'some': 'data'}
def test_get_table_meta(self): """Test get table meta""" # Run metadata = Mock() metadata._metadata = { 'tables': { 'test': {'some': 'data'} } } table_name = 'test' result = Metadata.get_table_meta(metadata, table_name) # Asserts expected = {'some': 'data'} assert result == expected
def _validate_arguments(synth, real, metadata, root_path, table_name): """Validate arguments needed to compute descriptors values. If ``metadata`` is an instance of dict create the ``Metadata`` object. If ``metadata`` is ``None``, ``real`` has to be a ``pandas.DataFrane``. If ``real`` is ``None`` load all the tables and assert that ``synth`` is a ``dict``. Otherwise, ``real`` and ``synth`` must be of the same type. If ``synth`` is not a ``dict``, create a dictionary using the ``table_name``. Assert that ``synth`` and ``real`` must have the same tables. Args: synth (dict or pandas.DataFrame): Synthesized data. real (dict, pandas.DataFrame or None): Real data. metadata (str, dict, Metadata or None): Metadata instance or details needed to build it. root_path (str): Path to the metadata file. table_name (str): Table name used to prepare the metadata object, real and synth dict. Returns: tuple (dict, dict, Metadata): Processed tables and Metadata oject. """ if isinstance(metadata, dict): metadata = Metadata(metadata, root_path) elif metadata is None: if not isinstance(real, pd.DataFrame): raise TypeError( 'If metadata is None, `real` has to be a DataFrame') metadata = Metadata() metadata.add_table(table_name, data=real) if real is None: real = metadata.load_tables() if not isinstance(synth, dict): raise TypeError('If `real` is `None`, `synth` must be a dict') elif not isinstance(synth, type(real)): raise TypeError('`real` and `synth` must be of the same type') if not isinstance(synth, dict): synth = {table_name: synth} if not isinstance(real, dict): real = {table_name: real} if not set(real.keys()) == set(synth.keys()): raise ValueError( 'real and synthetic dataset must have the same tables') if len(real.keys()) < len(metadata.get_tables()): meta_dict = { table: metadata.get_table_meta(table) for table in real.keys() } metadata = Metadata({'tables': meta_dict}) return synth, real, metadata