Performance benchmarks:

Thanks for this PR and for addressing my initial comments.

As you can see in the benchmark, deepcopy adds substantial overhead. So, I am not sure whether this is the ideal solution for this bug. It is a wasteful operation in the case of immutables, and expensive in the case of complicated, nested data structures. Moreover, if I am not mistaken, returning collections will break some of the downstream behavior of the data collector, such as returning dataframes. So I am curious if there are alternative solutions that don't have this overhead.

One option is to simply not allow mutables as a return to datacollector. Which, in my experience, should not be a significant problem since people typically collect simple data (i.e., numbers instead of mutable collections).

@Nithin9585 @quaquel

I guess we can use type-aware approach.

def get_reports(agent):
        _prefix = (agent.model.steps, agent.unique_id)
        reports = []
        for rep in rep_funcs:
            value = rep(agent)
            # only copy known mutable types
            if isinstance(value, (list, dict, set, bytearray)):
                reports.append(deepcopy(value))
            elif hasattr(value, '__array__'):  # numpy arrays
                reports.append(value.copy())
            else:
                reports.append(value)  # immutable types: int, float, str, tuple
        return _prefix + tuple(reports)

I have to think about this a bit more. Your code, as given, will solve the problem only for known mutable types, but will still silently work fine for user-defined classes. I am inclined instead to limit data that can be collected to only known built-in immutable types. Which is a much tighter constraint.

Alternatively, you could do something like

python_immutable_types = [str, int, long, bool, float, tuple,]

if insintance(value, *python_immutable_types)
   reports.append(value)
else:
   reports.append(copy.deepcopy(value))

At least, this avoids the expensive deepcopy in 80% of all cases, if not more.

@quaquel Implemented your suggested approach:

python
python_immutable_types = (str, int, bool, float, tuple)
if isinstance(value, python_immutable_types):
    reports.append(value)
else:
    reports.append(deepcopy(value))

This avoids deepcopy overhead for primitives (80%+ of cases) while still fixing the bug. All 16 tests pass.

Performance benchmarks: