def test_stack_on_complete_callback(self):
self.cloudformation.create_stack = Mock(return_value=StatusChanger("CREATE_COMPLETE", 0.1))
stkr = stacker.Stacker("example", {}, cloudformation=self.cloudformation)
mem = {"called": False}
def callback():
mem["called"] = True
stkr.setup(on_complete=callback)
self.assertTrue(mem["called"])
def test_client_error(self):
error_response = {
"Error": {
"Code": "ExampleClientError",
"Message": "Something happened"
}
}
self.cloudformation.create_stack = Mock(side_effect=botocore.exceptions.ClientError(error_response, "CreateStack"))
stkr = stacker.Stacker("example", {}, cloudformation=self.cloudformation)
self.assertFalse(stkr.setup())
def test_bad_coverage_cv(self):
"""test the case where a the input contains a cross validation strategy that fails to cover all
of the input indices"""
with self.assertRaises(ValueError):
stacker.Stacker(first_level_preds=[
Pipeline([('pca', PCA()),
('dtr', DecisionTreeRegressor(random_state=1))]),
LinearRegression()
],
stacker_pred=SVR(),
cv_fn=self._bad_cv_fun(),
n_jobs=-1)
def test_overfitting_resilience(self):
"""test that the stacker is robust to first level estimators that demonstrate overfitting
(the stacker is expected to give low weight to the overfitted member)"""
from sklearn.datasets import load_boston
X, y = load_boston(return_X_y=True)
tr, te = self._default_cv_fun().split(X).next()
X_train, X_test = X[tr], X[te]
stck = stacker.Stacker(first_level_preds=[
DecisionTreeRegressor(random_state=1),
BadPredictor()
],
stacker_pred=LinearRegression(),
cv_fn=self._default_cv_fun(),
n_jobs=-1)
stck.fit(X[tr], y[tr])
self.assertGreater(abs(stck._stacker_pred.coef_[0]),
abs(stck._stacker_pred.coef_[1]))
def test_basic_operation(self):
""""test basic usage of the stacking ensemble"""
from sklearn.datasets import load_boston
X, y = load_boston(return_X_y=True)
tr, te = self._default_cv_fun().split(X).next()
X_train, X_test = X[tr], X[te]
stck = stacker.Stacker(first_level_preds=[
Pipeline([('pca', PCA()),
('dtr', DecisionTreeRegressor(random_state=1))]),
LinearRegression()
],
stacker_pred=SVR(),
cv_fn=self._default_cv_fun(),
n_jobs=-1)
stck.fit(X[tr], y[tr])
y_hat = stck.predict(X[te])
score = sklearn.metrics.r2_score(y[te], y_hat)
self.assertGreater(score, 0)
def main():
if not os.environ.get('OS_CEILOMETER_URL'):
print("ERROR: $OS_CEILOMETER_URL variable not set!")
print(
"Use this as an example: OS_CEILOMETER_URL=https://compute.datacentred.io:8777"
)
exit(1)
parser = argparse.ArgumentParser()
parser.add_argument("stack_id",
help="The ID or name of the stack with resources.")
parser.add_argument("--verbose",
help="increase output verbosity",
action="store_true")
args = parser.parse_args()
verbose = False
if args.verbose:
print("INFO: Verbosity turned on.")
verbose = True
# get a token
creds = credentials.Credentials()
token = creds.get_token()
# use the token with ceilometer's endpoint
# NOTE: Sadly, the official client doesn't seem to work with the `limit` parameter.
# NOTE: Use the new custom class.
#
#cclient = ceilometerclient.client.get_client(2,
# os_endpoint=os.environ['OS_CEILOMETER_URL'],
# os_token=token)
#query_samples = [dict(field='meter', op='eq', value='instance')]
#print( cclient.samples.list( q=query_samples, limit=1 ) )
ceilomar = ceilomarius.Ceilomarius(
api_version=2,
endpoint=os.environ['OS_CEILOMETER_URL'],
token=token,
verbose=verbose)
stack_id = args.stack_id
stack = stacker.Stacker()
resources = stack.get_resources_in_stack(stack_id)
# stores every meter associated with resources from this stack
meters_all = dict()
for res in resources:
if verbose:
print("INFO: Retrieved resource: %s" % res)
meters_all.update(ceilomar.get_meters_for_resource(res, limit=1))
if verbose:
for key in meters_all.keys():
print("INFO: All meters retrieved from the stack:")
print("INFO: The main key: %s" % key)
print("INFO: Values for this key:")
for item in meters_all.get(key):
print("INFO: counter_name: {}, resource_id: {}, timestamp: {}".
format(item.get('counter_name'), item.get('resource_id'),
item.get('timestamp')))
# variables for stats on the number of found meters
n_required = 0
n_found = 0
# read required meters from a file
with open('required_meters.txt', 'r') as f:
for line in f:
meter = line.strip()
if meter in meters_all:
for item in meters_all[meter]:
print("meter: {meter} -> timestamp: {timestamp}".format(
meter=item.get('counter_name'),
timestamp=item.get('timestamp')))
if verbose:
print("INFO: Resource metadata:")
print("INFO: {}".format(item.get('resource_metadata')))
n_found += 1
n_required += 1
print("Found {} out of all {} meters!".format(n_found, n_required))
def test_unexpected_status(self):
self.cloudformation.create_stack = Mock(return_value=StatusChanger("UNEXPECTED", 1))
stkr = stacker.Stacker("example", {}, cloudformation=self.cloudformation)
self.assertFalse(stkr.setup())