def test_call_and_target():
class F(object):
def __init__(s, a, b, c):
s.a, s.b, s.c = a, b, c
call_f = Call(F, kwargs=dict(a=T, b=T, c=T))
assert repr(call_f)
val = glom(1, call_f)
assert (val.a, val.b, val.c) == (1, 1, 1)
class F(object):
def __init__(s, a):
s.a = a
val = glom({'one': F('two')}, Call(F, args=(T['one'].a, )))
assert val.a == 'two'
assert glom({'a': 1}, Call(F, kwargs=T)).a == 1
assert glom([1], Call(F, args=T)).a == 1
assert glom(F, T(T)).a == F
assert glom([F, 1], T[0](T[1]).a) == 1
assert glom([[1]], S[UP][Literal(T)][0][0]) == 1
assert glom([[1]], S[UP][UP][UP][Literal(T)]) == [[1]] # tops out
assert list(glom({'a': 'b'}, Call(T.values))) == ['b']
with pytest.raises(TypeError, match='expected func to be a callable or T'):
Call(func=object())
assert glom(lambda: 'hi', Call()) == 'hi'
return
def test_literal():
expected = {'value': 'c', 'type': 'a.b'}
target = {'a': {'b': 'c'}}
val = glom(target, {'value': 'a.b', 'type': Literal('a.b')})
assert val == expected
assert glom(None, Literal('success')) == 'success'
assert repr(Literal(3.14)) == 'Literal(3.14)'
def deconstruction_specs(cls):
"""
Return a list of deconstruction_specs=dict(description='doc string',
check_type='callable for checking if obj satisfies spec',
spec='describes how to generate ctor_dict',
validate_conversion='optional callable comparing obj to ctor_dict')
"""
return [
{
'description':
'For numpy.ndarray',
'check_type':
lambda x: isinstance(x, np.ndarray),
'spec': {
Ctor.CONSTRUCTOR: Literal(np.array),
Ctor.ARGS: lambda x: [x.tolist()],
Ctor.KWARGS: Literal(None),
},
'validate_conversion':
lambda x, serialized_x: np.allclose(
x, Ctor._construct_obj(serialized_x)),
},
{
'description':
'For objects that have from_jdict and to_jdict methods',
'check_type':
lambda x: hasattr(x, 'from_jdict') and hasattr(x, 'to_jdict'),
'spec': {
Ctor.CONSTRUCTOR: lambda x: type(x).from_jdict,
Ctor.ARGS: lambda x: [x.to_jdict()],
Ctor.KWARGS: Literal(None),
},
'validate_conversion':
lambda x, serialized_x: x.to_jdict() == Ctor._construct_obj(
serialized_x).to_jdict(),
},
{
'description':
'for class methods or class constructors',
'check_type':
lambda x: inspect.ismethod(x) or inspect.isclass(x),
'spec': {
Ctor.CONSTRUCTOR:
Literal(cls._deserialize_ctor_from_jdict),
Ctor.ARGS: lambda x: [cls._serialize_ctor_to_jdict(x)],
Ctor.KWARGS: Literal(None),
},
'validate_conversion':
lambda x, serialized_x: np.allclose(
x, Ctor._construct_obj(serialized_x)),
},
]
def classes_sync(master_id, environments):
cert_instance = CertsClass(master_id)
cert_path = cert_instance.get_cert()
private_key_path = cert_instance.get_key()
master_address = cert_instance.get_master_address()
url = f"https://{master_address}:8140/puppet/v3/environment_classes/"
data = []
for environment in environments:
req = requests.get(
f"{url}?environment={environment}",
verify=False,
cert=(cert_path, private_key_path),
)
target = req.json()["files"]
spec = [
Coalesce(
(
"classes",
[{
"name":
"name",
"params": (
"params",
[{
"name":
"name",
"type":
Coalesce("type", Literal("String")),
"default_source":
Coalesce("default_source", Literal("")),
}],
),
"master":
Literal(master_id),
}],
),
Literal([]),
)
]
for class_data in list(chain(*glom(target, spec))):
class_data["environment"] = environment
data.append(class_data)
user = os.environ.get("WEBAPP_USER", "")
password = os.environ.get("WEBAPP_PASS", "")
requests.post("http://webapp:8000/api/classes/sync/",
json=data,
auth=(user, password))
def nodes_sync(master_id, master_address):
cert_instance = CertsClass(master_id)
cert_path = cert_instance.get_cert()
private_key_path = cert_instance.get_key()
req = requests.get(
f"https://{master_address}:8081/pdb/meta/v1/version",
verify=False,
cert=(cert_path, private_key_path),
)
if req.status_code == 404:
# PuppetDB <= 2.x
nodes_uri = f"https://{master_address}:8081/v4/nodes"
else:
# PuppetDB >= 3.x
nodes_uri = f"https://{master_address}:8081/pdb/query/v4/nodes"
req = requests.get(nodes_uri,
verify=False,
cert=(cert_path, private_key_path))
target = req.json()
spec = [{"certname": "certname", "master_zone": Literal(master_id)}]
user = os.environ.get("WEBAPP_USER", "")
password = os.environ.get("WEBAPP_PASS", "")
requests.post(
"http://webapp:8000/api/nodes/sync/",
json=glom(target, spec),
auth=(user, password),
)
def field_expression(f):
if isinstance(f, PhoneNumberField):
return (f.name, Coalesce("as_e164", default=""))
elif isinstance(f, GeometryField):
return (f.name, str)
elif isinstance(f, CountryField):
return (f.name, str)
elif isinstance(f, StdImageField):
return (f.name,
lambda u: settings.FRONT_DOMAIN + settings.MEDIA_URL + u.url)
elif f.name == "password":
return Literal("(caché)")
return f.name
def test_let():
data = {'a': 1, 'b': [{'c': 2}, {'c': 3}]}
output = [{'a': 1, 'c': 2}, {'a': 1, 'c': 3}]
assert glom(data, (Let(a='a'), ('b', [{'a': S['a'], 'c': 'c'}]))) == output
assert glom(data, ('b', [{
'a': S[ROOT][Literal(T)]['a'],
'c': 'c'
}])) == output
with pytest.raises(TypeError):
Let('posarg')
with pytest.raises(TypeError):
Let()
assert repr(Let(a=T.a.b)) == 'Let(a=T.a.b)'
def _parse_api_response(resp_json):
"""Parse the json returned by the alerts API and extract relevant bits."""
service_subspec = {
'ServiceType': 'ServiceType',
'ServiceTypeDescription': 'ServiceTypeDescription',
'ServiceName': 'ServiceName',
'ServiceId': 'ServiceId'
}
spec = (
'CTAAlerts.Alert',
[
# for each entry in CTAAlerts.Alert pull out the following info
{
'AlertId': ('AlertId', int),
'ShortDescription':
'ShortDescription',
'FullDescription':
'FullDescription.#cdata-section',
'Impact':
'Impact',
'SeverityScore': ('SeverityScore', int),
'LastSeen':
Literal(pytz.UTC.localize(dt.datetime.utcnow()).isoformat()),
'EventStart':
Coalesce(('EventStart', _chicago_to_utc), default=None),
'EventEnd':
Coalesce(('EventEnd', _chicago_to_utc), default=None),
# pull out each entry in ImpactedService if there are multiple
'ImpactedService': (
'ImpactedService.Service',
# some chicanery to make sure this entry is always a
# list even though the API just returns a nested dict
# when there's only one service
lambda s: glom(s, [service_subspec])
if isinstance(s, list) else [glom(s, service_subspec)])
}
])
return glom(resp_json, spec)
"Vendor Contact Email": "third_party_contact_email",
"Vendor Contact Phone": "third_party_contact_phone",
# Assessment Order Info
"Order Assessment Tier": "assessment_order",
}
# Better change of mapping to column headers
HEADER_MAPPING.update({k.lower().strip(): v for k, v in HEADER_MAPPING.items()})
HEADER_MAPPING.update({k.upper().strip(): v for k, v in HEADER_MAPPING.items()})
HEADER_MAPPING.update({re.sub(r"[^0-9a-zA-Z ]+", "", k): v for k, v in HEADER_MAPPING.items()})
HEADER_MAPPING.update({k.replace(" ", "_"): v for k, v in HEADER_MAPPING.items()})
HEADER_MAPPING.update({k.replace(" ", ""): v for k, v in HEADER_MAPPING.items()})
COMPANY_SCHEMA = {
"name": "name",
"subscription_status": Literal(None),
"address": {"city": Literal("Denver"), "country": Literal("USA"),},
# Map the assessment order column to a valid order request, skip this field if it is not present or invalid
"order_info": Coalesce(("assessment_order", valid_assessment_order), default=OMIT),
"third_party_contact": (
{
# Prefer the first and last name from the spread sheet, fallback to using the email address
"first_name": (
Coalesce(
("third_party_contact_first_name", required),
("third_party_contact_name", split(False), required),
("third_party_contact_email", email_metadata("first_name")),
default=OMIT,
),
skip_falsy,
),