The user is reporting a bug where `clone` fails when parameters are estimator types (classes) rather than instances. Let me look at the code to understand the issue and fix it. Let me start by reading the `base.py` file to understand the `clone` function.

Now I can see the issue. Let me look at the `clone` function more carefully. The problem is in the `clone` function. When you call `clone(StandardScaler(with_mean=StandardScaler))`, the parameter `with_mean` is set to the class `StandardScaler` (not an instance). When iterating over the parameters: 1. For each parameter, `clone(param, safe=False)` is called 2. When `param` is the `StandardScaler` class (a type), `hasattr(estimator, 'get_params')` returns `True` because classes have a `get_params` method (it's defined on `BaseEstimator` and inherited by `StandardScaler`) 3. But then `estimator.get_params(deep=False)` is called on the class itself, not an instance, which fails because `get_params` expects `self` (an instance). The fix suggested by the user is: ```python elif not hasattr(estimator, 'get_params') or isinstance(estimator, type): ``` This would check if the estimator is a type (class), and if so, treat it as if it doesn't have `get_params` (since we can't call it without an instance). This seems reasonable. But wait, let me think about this more carefully. When `safe=False`, the code falls back to `copy.deepcopy(estimator)`. This would deep copy the class, which is probably fine for classes. But actually, `deepcopy` on a class would just return the same class (classes are singletons essentially). Let me verify: actually, `copy.deepcopy` on a type returns the type itself in most cases, which is fine. But wait, there's another subtlety. When we have a parameter value that is a class type, and `safe=False`, `clone` will call `copy.deepcopy(param)` on it. This should work fine. But what about when `safe=True`? The initial call to `clone` has `safe=True` by default. The recursive calls within the parameter loop use `safe=False`. So the class type would only be encountered in the recursive calls with `safe=False`. So the fix should work: when we encounter a type (class), we should treat it as not having a usable `get_params` method, and fall back to deep copy (since `safe=False` in the recursive call). Let me implement the fix.

Now I understand the bug. Looking at the `clone` function: 1. When `clone` is called on an estimator with a class-type parameter (like `StandardScaler(with_mean=StandardScaler)`), it iterates over parameters and recursively calls `clone(param, safe=False)` on each. 2. For the class `StandardScaler`, `hasattr(estimator, 'get_params')` returns `True` because the class *has* a `get_params` method (it's defined on `BaseEstimator`). 3. But then `estimator.get_params(deep=False)` is called on the **class** (not an instance), which fails because it's missing `self`. The fix is to also check whether the estimator is a type (class), and if so, treat it as not having a usable `get_params` method:

Now let me verify the fix works by running a quick test:

Now let me verify the fix works:

The clone succeeded but now there's an issue with `get_params` on the cloned object. Let me trace through the issue. When we call `clone(StandardScaler(with_mean=StandardScaler))`: 1. First, `estimator` is an instance of `StandardScaler` with `with_mean=StandardScaler` (the class). 2. `hasattr(estimator, 'get_params')` is True. 3. `new_object_params = estimator.get_params(deep=False)` — this works, it returns `{'copy': True, 'with_mean': StandardScaler, 'with_std': True}`. 4. Then for each param, `clone(param, safe=False)` is called. For the `StandardScaler` class, our fix makes it go to `copy.deepcopy(StandardScaler)` which returns `StandardScaler`. 5. `new_object = klass(**new_object_params)` — this creates a new `StandardScaler` with `with_mean=StandardScaler`. 6. `params_set = new_object.get_params(deep=False)` — this works fine, it returns `{'copy': True, 'with_mean': StandardScaler, 'with_std': True}`. Wait, the error happens on `result.get_params()`, not on the clone itself. That's odd. Let me check what `get_params` does when `deep=True`: ```python def get_params(self, deep=True): out = dict() for key in self._get_param_names(): value = getattr(self, key, None) if deep and hasattr(value, 'get_params'): deep_items = value.get_params().items() out.update((key + '__' + k, val) for k, val in deep_items) out[key] = value return out ``` When `deep=True` (the default), and `value` is the `StandardScaler` class, `hasattr(value, 'get_params')` is `True` (because the class has the method), but calling `value.get_params()` fails because it's called on the class, not an instance. So the fix in `clone` is fine, but there's also a similar issue in `get_params`. Should we fix `get_params` too? The issue description only mentions `clone`, but the deeper issue is that `hasattr(SomeEstimatorClass, 'get_params')` returns `True` for estimator classes, and treating them as estimators fails. The user's fix only addresses `clone`. But `get_params` also has this problem. However, `get_params` is an instance method, so it would only be called if someone explicitly passes a class as an estimator parameter. The clone fix allows the clone to succeed, but then calling `get_params(deep=True)` on the resulting object would still fail. Let me think about whether we should also fix `get_params`. The user's bug report is specifically about `clone`. But `get_params` has the same type of issue. Let me check if there are existing tests. Actually, I think the proper fix should also handle this in `get_params`. Let me check: when `deep=True` in `get_params`, and a parameter value is an estimator class, we should skip the deep parameter extraction for it. Let me also fix `get_params` to handle cases where a parameter value is a class (type) that happens to have `get_params`:

The clone succeeds now, but there's a related issue in `get_params`. When `deep=True` and a parameter value is an estimator class (not instance), `hasattr(value, 'get_params')` returns `True` but calling `value.get_params()` fails. Let me fix that too:

Now let me test again.

Both fixes work. Let me also run the existing tests to make sure nothing is broken:

Both fixes work. Let me run the existing tests for `base.py` and `clone` to make sure nothing is broken: