def __init__(self, **kwargs):
        districts = self._try_load_district_dataset(**kwargs)
        if districts is not None:
            district_ids = districts.get_id_attribute()
            OD_array = array([[x, y] for x in district_ids for y in district_ids])

            storage = StorageFactory().get_storage("dict_storage")

            storage.write_table(
                table_name=self.in_table_name_default,
                table_data={
                    "commute_id": OD_array[:, 0] * 1000 + OD_array[:, 1],
                    "origin_district_id": OD_array[:, 0],
                    "destination_district_id": OD_array[:, 1],
                },
            )

            UrbansimDataset.__init__(
                self,
                in_storage=storage,
                # in_table_name=self.in_table_name_default,
                # id_name=self.id_name_default,
                # dataset_name=self.dataset_name
            )
        else:
            UrbansimDataset.__init__(self, **kwargs)

    def __init__(self, id_values=1, **kwargs):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='regions',
            table_data={
                self.id_name_default:array([id_values])
                }
            )

        resources = Resources({
            'in_storage':storage,
            'in_table_name':'regions'
            })

        UrbansimDataset.__init__(self, resources=resources, **kwargs)

    def _compute_if_needed(self, name, dataset_pool, resources=None, quiet=False, version=None):
        """ Compute variable given by the argument 'name' only if this variable
        has not been computed before.
        Check first if this variable belongs to dataset1 or dataset2.
        dataset_pool holds available datasets.
        """
        if not isinstance(name, VariableName):
            variable_name = VariableName(name)
        else:
            variable_name = name
        short_name = variable_name.get_alias()

        dataset_name = variable_name.get_dataset_name()
        if dataset_name == self.get_dataset_name():
            new_version = UrbansimDataset._compute_if_needed(self, variable_name, dataset_pool, resources, quiet=quiet, version=version)
        else:
            if dataset_name == self.dataset1.get_dataset_name():
                owner_dataset = self.dataset1
#                index = self.get_2d_index_of_dataset1()
            elif dataset_name == self.dataset2.get_dataset_name():
                owner_dataset = self.dataset2
#                index = self.get_2d_index()
            else:
                self._raise_error(StandardError, "Cannot find variable '%s'\nin either dataset or in the interaction set." %
                                variable_name.get_expression())
            owner_dataset.compute_variables([variable_name], dataset_pool, resources=resources, quiet=True)
            new_version =  self.compute_variables_return_versions_and_final_value("%s = %s.disaggregate(%s.%s)" % \
                                   ( short_name, self.get_dataset_name(), owner_dataset.get_dataset_name(), short_name ),
                                   dataset_pool=dataset_pool, resources=resources, quiet=quiet )[0]
        return new_version

    def __init__(self, submarket_definition=[], **kwargs):
        if submarket_definition:
            self.submarket_definition = submarket_definition
            
        dataset, short_names, submarket_ids = self.solve_dependencies(**kwargs)
        table_data = {}
            
        table_data['submarket_id'], unique_index = unique( submarket_ids, return_index=True )
        
        table_data.update([(short_name, dataset[short_name][unique_index]) for short_name in short_names])

        storage = StorageFactory().get_storage('dict_storage')        
        storage.write_table(table_name=self.in_table_name_default,
                            table_data=table_data
                            ) 
    
        UrbansimDataset.__init__(self, in_storage=storage, 
                                 #in_table_name=self.in_table_name_default, 
                                 #id_name=self.id_name_default, 
                                 #dataset_name=self.dataset_name
                             )

 def get_2d_attribute(self, attribute):
     return UrbansimDataset.get_2d_attribute(self, attribute=attribute)

 def flatten_by_id(self, two_d_array):
     return UrbansimDataset.flatten_by_id(self, two_d_array)

 def __init__(self, *args, **kwargs):
     UrbansimDataset.__init__(self, *args, **kwargs)
     self.mask = None

 def __init__(self, id_values=None, **kwargs):
     UrbansimDataset.__init__(self, **kwargs)
     self.development_constraints = None

 def __init__(self, what='', resources=None, **kwargs):
     # what is a legacy argument that is not used any more
     UrbansimDataset.__init__(self, resources, **kwargs)
     self.independent_variables = []

 def __init__(self, resources=None, dataset1=None, dataset2=None, index1=None, index2=None, **kwargs):
     """ This dataset is an interaction of two datasets (originally, parcel and development template).
         It's similar to InteractionSet, but flattend to 1d, thus regression model can use this dataset without changes
     """
     UrbansimDataset.__init__(self, resources=resources, **kwargs)
     self._set_my_class_attributes(dataset1, dataset2, index1, index2)

 def _update_id_mapping(self):
     UrbansimDataset._update_id_mapping(self)
     self._create_id_mapping_array()

 def __init__(self, *args, **kwargs):
     UrbansimDataset.__init__(self, *args, **kwargs)               
     
     self.low_income_level = -1
     self.mid_income_level = -1