#
 from mlos.Examples.SmartCache.CacheImplementations.XruCache import XruCache
 from mlos.Spaces import DiscreteDimension, Point, SimpleHypergrid
-from mlos.Spaces.Configs.DefaultConfigMeta import DefaultConfigMeta
+from mlos.Spaces.Configs.ComponentConfigStore import ComponentConfigStore
 
-class LruCacheConfig(metaclass=DefaultConfigMeta):
-    CONFIG_SPACE = SimpleHypergrid(
+LruCacheConfigStore = ComponentConfigStore(

+# Troubleshooting Tips++Here are some common tips for troubleshooting various issues.++## Contents++- [Troubleshooting Tips](#troubleshooting-tips)+  - [Contents](#contents)+  - [Editor Integrations](#editor-integrations)+    - [VSCode in WSL](#vscode-in-wsl)+      - ["Missing .Net SDK" message when executing `code .` in WSL](#missing-net-sdk-message-when-executing-code--in-wsl)++## Editor Integrations++### VSCode in WSL++#### "Missing .Net SDK" message when executing `code .` in WSL++The [Omnisharp](https://github.com/OmniSharp/omnisharp-vscode/wiki/Troubleshooting:-'The-.NET-Core-SDK-cannot-be-located.'-errors) plugin for VSCode may have trouble finding the `dotnet` setup locally for the MLOS repo in `tools/`, even if you source the `scripts/init.linux.sh` script to setup your `PATH` environment.++To workaround this issue, you can [install `dotnet` system wide for your WSL2 distro](https://docs.microsoft.com/en-us/dotnet/core/install/linux).++Here are the instructions for Ubuntu 20.04:\+<https://docs.microsoft.com/en-us/dotnet/core/install/linux-ubuntu#2004->

+# Troubleshooting Tips++Here are some common tips for troubleshooting various issues.++## Contents++- [Troubleshooting Tips](#troubleshooting-tips)+  - [Contents](#contents)+  - [Editor Integrations](#editor-integrations)+    - [VSCode in WSL](#vscode-in-wsl)+      - ["Missing .Net SDK" message when executing `code .` in WSL](#missing-net-sdk-message-when-executing-code--in-wsl)++## Editor Integrations++### VSCode in WSL++#### "Missing .Net SDK" message when executing `code .` in WSL++The [Omnisharp](https://github.com/OmniSharp/omnisharp-vscode/wiki/Troubleshooting:-'The-.NET-Core-SDK-cannot-be-located.'-errors) plugin for VSCode may have trouble finding the `dotnet` setup locally for the MLOS repo in `tools/`, even if you source the `scripts/init.linux.sh` script to setup your `PATH` environment.++To workaround this issue, you can [install `dotnet` system wide for your WSL2 distro](https://docs.microsoft.com/en-us/dotnet/core/install/linux).++Here are the instructions for Ubuntu 20.04:\+<https://docs.microsoft.com/en-us/dotnet/core/install/linux-ubuntu#2004->

 main(             CyclicalWorkload(2048, smartCache);         } +        // After having run a workload for a while, we want to check for a new+        // config suggestion from an optimizer.+        // In this case we make it a blocking call.++        // First, create some condition variables to help signal when the new+        // config is ready to be consumed.+        //         bool isConfigReady = false;         std::mutex waitForConfigMutex;         std::condition_variable waitForConfigCondVar; -        // Setup a callback.+        // Also, setup a callback lambda function for handling the+        // SharedConfigUpdatedFeedbackeMessage we expect to receive from the+        // agent after we request a config update with a RequestNewConfigurationMessage.+        //+        // Note: this lambda will be invoked by the background task setup above+        // for processing messages on the feedback channel.         //         ObjectDeserializationCallback::Mlos::Core::SharedConfigUpdatedFeedbackMessage_Callback =             [&waitForConfigMutex, &waitForConfigCondVar,              &isConfigReady](Proxy::Mlos::Core::SharedConfigUpdatedFeedbackMessage&& msg)             {-                // Ignore the message.+                // The contents of the message are irrelevant in this case.+                // It's just a signal that the RequestNewConfigurationMessage+                // has been processed by the agent.                 //                 UNUSED(msg); +                // So, we will just notify the waiting loop (below) that the+                // message has been processed now and is ready to be read.+                //                 std::unique_lock<std::mutex> lock(waitForConfigMutex);                 isConfigReady = true;                 waitForConfigCondVar.notify_all();             }; -        // Send a request to obtain a new configuration.+        // Send a request to obtain a new configuration from the optimizer.+        //+        // Note: the message (as defined in+        // SmartCache.SettingsRegistry/CodeGen/SmartCache.cs) has no members, so+        // there's no details to fill in here (and it is just zero-initialized).+        // It's simply a signal to send to the external agent to request a new+        // config be populated in the shared memory region.         //         SmartCache::RequestNewConfigurationMessage msg = { 0 };         mlosContext.SendTelemetryMessage(msg); +        // Now, we wait for the external agent to respond to our request.

 public static void Main(string[] args)                 //
                 AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
 
+                // This populates a variable for the various settings registry
+                // callback handlers to use (by means of their individual
+                // AssemblyInitializers) to know how they can connect with the
+                // optimizer.
+                //
+                // See Also: AssemblyInitializer.cs within the SettingsRegistry
+                // assembly project in question.
+                //
                 Uri optimizerAddressUri = new Uri("http://localhost:50051");
                 MlosContext.OptimizerFactory = new MlosOptimizer.BayesianOptimizerFactory(optimizerAddressUri);
             }
 
-            // Create circular buffer shared memory before running the target process.
+            // Create (or open) the circular buffer shared memory before running the target process.
             //
             MainAgent.InitializeSharedChannel();
 
-            // Active learning, almost done. In active learning the MlosAgentServer controls the workload against the target component.
+            // Active learning mode.
+            // In active learning the MlosAgentServer controls the workload against the target component.

 // for license information.
 // </copyright>
 // -----------------------------------------------------------------------
+//
+// This file contains the data structures that represent both the component
+// settings as well as the component specific messages it can send to and
+// receive from the agent.
+//
+// Note: they are annotated with C# attributes that allow the MLOS code
+// generation process to walk the structures using reflection.
+//
+// The .csproj file for this SettingsRegistry assembly specially declares this
+// file as relevant (SettingsRegistryDef) to for Mlos.SettingsSystem.CodeGen to
+// invoke that process.
+//
+// Then according to those rules the code generation output by default is
+// sent to out/Mlos.CodeGen.out/SmartCache/SettingsProvider_gen_*.*
+//
+// Different settings registries are separated to different folders (and
+// optionally namespaces - see SmartCache/CodeGen/AssemblyInfo.cs) to allow
+// multiple settings registries to be included in the same project.
+//
+// Mlos.SettingsSystem.CodeGen outputs for multiple languages (e.g. C++, C#,
+// etc.)
+//
+// For C++ the codegen are expected to be used with #include statements.

 // @File: Main.cpp // // Purpose:-//      <description>+//  The main entrypoint to the SmartCache example.+//+//  It's meant as an end-to-end microbenchmark example for the C++ version of the+//  SmartCache Python Notebook example.+//+//  It provides different cache replacement policies and cache sizes as tunables+//  for an optimizer to tune for different workloads. // // Notes: //      <special-instructions> // //********************************************************************* +// Include all the common headers for the application+// (including Mlos.Core and component settings registry code generation output)+// #include "stdafx.h" +// Include platform specific implementations of some Mlos functions.+// Only needed in one compilation unit for a given target.+// #include "MlosPlatform.Std.inl"  using namespace Mlos::Core; using namespace SmartCache; -// Include codegen files.-//-#include "GlobalDispatchTable.h"- #include "SmartCacheImpl.h" #include "Workloads.h" +// A basic Windows result code handler.

 main(     //     ISharedChannel& feedbackChannel = mlosContext.FeedbackChannel(); +    // This background thread uses a lambda to monitor the feedback channel for+    // new messages and process them using the callbacks registered for each+    // message type in the global dispatch table.+    //     std::future<bool> feedbackChannelReader = std::async(

 constexpr uint32_t SmartCache::ObjectDeserializationHandler::DispatchTableBaseIn     return static_cast<uint32_t>(Mlos::Core::ObjectDeserializationHandler::DispatchTableElementCount()); } +// Note: As additional settings registries are included in the same project the+// DispatchTableBaseIndex()s should be added together for each prior component+// corresponding to the DispatchTables that are concatenated below.+// See SmartSharedChannel/GlobalDispatchTable.h for an example.++// Registers each of the code generated messages for the channel message handler

 public static void Main(string[] args) 
             Task grpcServerTask = CreateHostBuilder(Array.Empty<string>()).Build().RunAsync(cancellationTokenSource.Token);
 
+            // Start the MainAgent message processing loop as a background thread.
+            //
+            // In MainAgent.RunAgent we loop on the shared memory control and
+            // telemetry channels looking for messages and dispatching they to

 private static void RequestNewConfigurationMessageHandler(SmartCacheProxy.Reques 
                     string currentConfigJsonString = JsonSerializer.Serialize(currentConfigDictionary, JsonOptions);
 
-                    // Register an observation.
+                    // Send (register) the observation with the optimizer.

 public static void Main(string[] args) 
             Task grpcServerTask = CreateHostBuilder(Array.Empty<string>()).Build().RunAsync(cancellationTokenSource.Token);
 
+            // Start the MainAgent message processing loop as a background thread.
+            //
+            // In MainAgent.RunAgent we loop on the shared memory control and
+            // telemetry channels looking for messages and dispatching they to
+            // their registered callback handlers.
+            //
+            // The set of recognized messages are dynamically registered using
+            // the RegisterSettingsAssembly method which is called through the
+            // handler for the RegisterAssemblyRequestMessage.
+            //
+            // Once registered, the SettingsAssemblyManager uses reflect to

 public static void Main(string[] args) 
             Task grpcServerTask = CreateHostBuilder(Array.Empty<string>()).Build().RunAsync(cancellationTokenSource.Token);
 
+            // Start the MainAgent message processing loop as a background thread.
+            //
+            // In MainAgent.RunAgent we loop on the shared memory control and
+            // telemetry channels looking for messages and dispatching they to
+            // their registered callback handlers.
+            //
+            // The set of recognized messages are dynamically registered using

 main(     //     ISharedChannel& feedbackChannel = mlosContext.FeedbackChannel(); +    // This background thread uses a lambda to monitor the feedback channel for+    // new messages and process them using the callbacks registered for each+    // message type in the global dispatch table.+    //     std::future<bool> feedbackChannelReader = std::async(         std::launch::async,         [&feedbackChannel]     {+        // GlobalDispatchTable defines the set of recognized messages by this+        // application.+        // See GlobalDispatchTable.h for details.+        //         auto globalDispatchTable = GlobalDispatchTable();++        // This starts a loop to handle reading messages from the feedback+        // channel, looking them up in the dispatch table, and calling the+        // callbacks associated with them.+        //         feedbackChannel.ProcessMessages(globalDispatchTable.data(), globalDispatchTable.size());          return true;     }); -    // Register Mlos.SmartCache Settings assembly.+    // Register the SmartCache.SettingsRegistry assembly with the external agent.+    //+    // This prepares the external agent to begin handling messages from our+    // smart component on new telemetry and feedback channels.+    //+    // To do that it sends a RegisterAssemblyRequestMessage to the agent on the+    // control channel that includes the name of settings registry (annotated C#+    // data structures used for code generation) assembly (dll) for this smart+    // component.+    //+    // When the (C#) agent receives that message it dynamically loads the+    // specified dll into its address space and calls an AssemblyInitializer+    // static class within that dll to setup the message handlers (callbacks).+    //+    // See Also: SmartCache.SettingsRegistry/AssemblyInitializer.cs     //     hr = mlosContext.RegisterSettingsAssembly(         "SmartCache.SettingsRegistry.dll",         SmartCache::ObjectDeserializationHandler::DispatchTableBaseIndex());     CheckHR(hr); -    // Create shared component configuration.+    // Create a component configuration object.+    // This will be stored in a shared memory region below for use by both the+    // component and the external agent.     //     Mlos::Core::ComponentConfig<SmartCache::SmartCacheConfig> config(mlosContext);      // Initialize config with default values.     //+    // TODO: Eventually we expect these default values to be initialized from+    // the SettingsRegistry code generation process themselves.+    //     config.ConfigId = 1;     config.EvictionPolicy = SmartCache::CacheEvictionPolicy::LeastRecentlyUsed;     config.CacheSize = 100; +    // Checks to see if there's already a shared memory region for storing the+    // config for this component and if not creates it.+    //     hr = mlosContext.RegisterComponentConfig(config);     CheckHR(hr); -    // Create an intelligent component.+    // Create an instance of our SmartCache component to tune.+    //+    // Note that we pass it a ComponentConfig instance, which also includes our+    // MlosContext instance, so that the component can internally send telemtry

 // @File: Main.cpp // // Purpose:-//      <description>+//  The main entrypoint to the SmartCache example.+//+//  It's meant as an end-to-end microbenchmark example for the C++ version of the+//  SmartCache Python Notebook example.+//+//  It provides different cache replacement policies and cache sizes as tunables+//  for an optimizer to tune for different workloads. // // Notes: //      <special-instructions> // //********************************************************************* +// Include all the common headers for the application+// (including Mlos.Core and component settings registry code generation output)+// #include "stdafx.h" +// Include platform specific implementations of some Mlos functions.

 def check_requires_y_none(name, estimator_orig, strict_mode=True):             warnings.warn(warning_msg, FutureWarning)  +def check_dataframe_column_names_consistency(name, estimator_orig):+    try:+        import pandas as pd+    except ImportError:+        raise SkipTest("pandas is not installed: not checking "+                       "column name consistency for pandas")++    def _construct_dataframe(X, columns):+        return pd.DataFrame(X, columns=columns)+    _check_column_name_consistency(name, estimator_orig, _construct_dataframe,+                                   "dataframe")+++def check_dataarray_column_names_consistency(name, estimator_orig):+    try:+        import xarray as xr+    except ImportError:+        raise SkipTest("xarray is not installed: not checking "+                       "column name consistency for xarray")++    def _construct_xarray(X, columns):+        return xr.DataArray(X, dims=('index', 'columns'),+                            coords={'columns': columns})+    _check_column_name_consistency(name, estimator_orig, _construct_xarray,+                                   "xarray")+++def _check_column_name_consistency(name, estimator_orig, construct_X,+                                   array_name):+    estimator = clone(estimator_orig)++    X_orig, _ = make_regression(random_state=0, n_features=10)+    X_orig = _enforce_estimator_tags_x(estimator, X_orig)+    X_orig = _pairwise_estimator_convert_X(X_orig, estimator)++    n_samples, n_features = X_orig.shape+    names = np.array([f"col_{i}" for i in range(n_features)])+    X = construct_X(X_orig, names)++    rng = np.random.RandomState(0)+    if is_regressor(estimator):+        y = rng.normal(size=n_samples)+    else:+        y = rng.randint(low=0, high=2, size=n_samples)+    y = _enforce_estimator_tags_y(estimator, y)

 def transform(self, X):         # Need not validate X again as it would have already been validated         # in the Imputer calling MissingIndicator         if not self._precomputed:-            X = self._validate_input(X, in_fit=True)

 def check_requires_y_none(name, estimator_orig, strict_mode=True):             warnings.warn(warning_msg, FutureWarning)  +def check_dataframe_column_names_consistency(name, estimator_orig):+    try:+        import pandas as pd+    except ImportError:+        raise SkipTest("pandas is not installed: not checking "+                       "column name consistency for pandas")++    def _construct_dataframe(X, columns):+        return pd.DataFrame(X, columns=columns)+    _check_column_name_consistency(name, estimator_orig, _construct_dataframe,+                                   "dataframe")+++def check_dataarray_column_names_consistency(name, estimator_orig):+    try:+        import xarray as xr+    except ImportError:+        raise SkipTest("xarray is not installed: not checking "+                       "column name consistency for xarray")++    def _construct_xarray(X, columns):+        return xr.DataArray(X, dims=('index', 'columns'),+                            coords={'columns': columns})+    _check_column_name_consistency(name, estimator_orig, _construct_xarray,+                                   "xarray")+++def _check_column_name_consistency(name, estimator_orig, construct_X,+                                   array_name):+    estimator = clone(estimator_orig)++    X_orig, _ = make_regression(random_state=0, n_features=10)+    X_orig = _enforce_estimator_tags_x(estimator, X_orig)+    X_orig = _pairwise_estimator_convert_X(X_orig, estimator)++    n_samples, n_features = X_orig.shape+    names = np.array([f"col_{i}" for i in range(n_features)])+    X = construct_X(X_orig, names)++    rng = np.random.RandomState(0)+    if is_regressor(estimator):

 def test_repr_html_wraps():     with config_context(display='diagram'):         output = tree._repr_html_()         assert "<style>" in output+++def test_feature_names_in():+    # Simple checks for feature_names_in+    pd = pytest.importorskip("pandas")+    iris = datasets.load_iris()+    df = pd.DataFrame(iris.data, columns=iris.feature_names)+    y = iris.target++    class NoOpTransformer(TransformerMixin, BaseEstimator):+        def fit(self, X, y):+            self._validate_data(X)+            return self++        def transform(self, X):+            self._validate_data(X, reset=False)+            return X++    trans = NoOpTransformer().fit(df, y)+    assert_array_equal(trans.feature_names_in_, df.columns)++    msg = "The column names should match those that were passed"

+import pytest

+import pytest++import numpy as np+from numpy.testing import assert_array_equal++from sklearn.utils._array_out import _get_feature_names+++def _construct_array(array_type, column_names):+    X = np.array([[1, 2, 3], [4, 5, 6]], dtype=float)++    if array_type == "dataframe":+        pd = pytest.importorskip("pandas")+        return pd.DataFrame(X, columns=column_names)+    elif array_type == "dataarray":+        xr = pytest.importorskip("xarray")+        return xr.DataArray(X, dims=('index', 'columns'),+                            coords={'columns': column_names})++[email protected]("array_type", ["dataframe", "dataarray"])+def test_pandas_get_feature_names(array_type):

 def _check_n_features(self, X, reset):                                        self.n_features_in_)                 ) +    def _check_feature_names(self, X, reset=True):+        """Validate feature names and set or check the `feature_names_in_`+        attribute.++        Parameters+        ----------+        X : {dataframe-like} of shape (n_samples, n_features)+            The input samples.+        reset : bool, default=True+            Whether to reset the `feature_names_in_` attribute.+            If False, the Input will be checked for consistency with data+            provided when reset was last True.+        """++        if reset:+            self.feature_names_in_ = _get_feature_names(X)+            return++        fitted_feature_names = getattr(self, "feature_names_in_", None)+        if fitted_feature_names is None:+            # no feature names to check+            return++        feature_names_in = _get_feature_names(X)

 def _check_n_features(self, X, reset):                                        self.n_features_in_)                 ) +    def _check_feature_names(self, X, reset=True):+        """Validate feature names and set or check the `feature_names_in_`+        attribute.++        Parameters+        ----------+        X : {dataframe-like} of shape (n_samples, n_features)+            The input samples.+        reset : bool, default=True+            Whether to reset the `feature_names_in_` attribute.+            If False, the Input will be checked for consistency with data