How to use the cumulusci.tasks.bulkdata.data_generation.data_gen_exceptions.DataGenError function in cumulusci

self.message = message
        self.filename = filename
        self.line_num = line_num
        assert isinstance(filename, (str, type(None)))
        assert isinstance(line_num, (int, type(None)))
        super().__init__(self.message)

    def __str__(self):
        return f"{self.message}\n near {self.filename}:{self.line_num}"


class DataGenSyntaxError(DataGenError):
    pass


class DataGenNameError(DataGenError):
    pass


class DataGenValueError(DataGenError):
    pass


def fix_exception(message, parentobj, e):
    """Add filename and linenumber to an exception if needed"""
    filename, line_num = parentobj.filename, parentobj.line_num
    if isinstance(e, DataGenError):
        if not e.filename:
            e.filename = filename
        if not e.line_num:
            e.line_num = line_num
        raise e

def exception_handling(self, message: str):
        try:
            yield
        except DataGenError:
            raise
        except Exception as e:
            raise DataGenError(f"{message} : {str(e)}", self.filename, self.line_num)

def create_tables_from_inferred_fields(tables, engine, metadata):
    """Create tables based on dictionary of tables->field-list."""
    for table_name, table in tables.items():
        columns = [Column(field_name, Unicode(255)) for field_name in table.fields]
        id_column = Column("id", Integer(), primary_key=True, autoincrement=True)

        t = Table(table_name, metadata, id_column, *columns)
        if t.exists():
            raise DataGenError(
                f"Table already exists: {table_name} in {engine.url}", None, None
            )

key_definition = expected_keys.get(key)
            if not key_definition:
                raise DataGenError(f"Unexpected key: {key}", **context.line_num(key))
            else:
                value = dct[key]
                if not isinstance(value, key_definition):
                    raise DataGenError(
                        f"Expected `{key}` to be of type {key_definition} instead of {type(value)}.",
                        **context.line_num(dct),
                    )
                else:
                    setattr(rc_obj, key, value)

        missing_keys = set(mandatory_keys) - set(dct.keys())
        if missing_keys:
            raise DataGenError(
                f"Expected to see `{missing_keys}` in `{element_type}``.",
                **context.line_num(dct),
            )
        defaulted_keys = set(optional_keys) - set(dct.keys())
        for key in defaulted_keys:
            setattr(rc_obj, key, None)

        return rc_obj

class DataGenError(Exception):
    def __init__(self, message, filename, line_num):
        self.message = message
        self.filename = filename
        self.line_num = line_num
        assert isinstance(filename, (str, type(None)))
        assert isinstance(line_num, (int, type(None)))
        super().__init__(self.message)

    def __str__(self):
        return f"{self.message}\n near {self.filename}:{self.line_num}"


class DataGenSyntaxError(DataGenError):
    pass


class DataGenNameError(DataGenError):
    pass


class DataGenValueError(DataGenError):
    pass


def fix_exception(message, parentobj, e):
    """Add filename and linenumber to an exception if needed"""
    filename, line_num = parentobj.filename, parentobj.line_num
    if isinstance(e, DataGenError):
        if not e.filename:

context.register_object(sobj, self.nickname)

        context.obj = sobj

        self._generate_fields(context, row)

        try:
            # both of these lines loop over the fields so they could maybe
            # be combined but it kind of messes with the modularity of the
            # code.
            self.register_row_intertable_references(row, context)
            storage.write_row(self.tablename, row)

        except Exception as e:
            raise DataGenError(str(e), self.filename, self.line_num) from e
        for i, childobj in enumerate(self.friends):
            childobj.generate_rows(storage, context)
        return sobj

def reference(context, x):
    """YAML-embeddable function to Reference another object."""
    if hasattr(x, "id"):  # reference to an object with an id
        target = x
    elif isinstance(x, str):  # name of an object
        obj = context.field_vars()[x]
        if not getattr(obj, "id"):
            raise DataGenError(f"Reference to incorrect object type {obj}", None, None)
        target = obj
    else:
        raise DataGenError(
            f"Can't get reference to object of type {type(x)}: {x}", None, None
        )

    return target