def build_classes(self,strict=False, named_only=False, standardize_names=True):
"""
Build all of the classes named in the JSONSchema.
Class names will be transformed using inflection by default, so names
with spaces in the schema will be camelcased, while names without
spaces will have internal capitalization dropped. Thus "Home Address"
becomes "HomeAddress", while "HomeAddress" becomes "Homeaddress" To
disable this behavior, pass standardize_names=False, but be aware
that accessing names with spaces from the namespace can be
problematic.
Args:
strict: (bool) use this to validate required fields while creating the class
named_only: (bool) If true, only properties with an actual title attribute will
be included in the resulting namespace (although all will be generated).
standardize_names: (bool) If true (the default), class names will be tranformed
by camel casing
Returns:
A namespace containing all the generated classes
"""
kw = {"strict": strict}
builder = classbuilder.ClassBuilder(self.resolver)
for nm, defn in iteritems(self.schema.get('definitions', {})):
uri = python_jsonschema_objects.util.resolve_ref_uri(
self.resolver.resolution_scope,
"#/definitions/" + nm)
builder.construct(uri, defn, **kw)
if standardize_names:
name_transform = lambda t: inflection.camelize(inflection.parameterize(six.text_type(t), '_'))
else:
name_transform = lambda t: t
nm = self.schema['title'] if 'title' in self.schema else self.schema['$id']
nm = inflection.parameterize(six.text_type(nm), '_')
builder.construct(nm, self.schema,**kw)
self._resolved = builder.resolved
classes = {}
for uri, klass in six.iteritems(builder.resolved):
title = getattr(klass, '__title__', None)
if title is not None:
classes[name_transform(title)] = klass
elif not named_only:
classes[name_transform(uri.split('/')[-1])] = klass
return python_jsonschema_objects.util.Namespace.from_mapping(classes)
def dashboard_create():
"""Create a new dashboard with an empty definition.
"""
dashboard = database.DashboardRecord.from_json(request.json)
if not dashboard.title:
return {'error_message': "Missing required field 'title'"}, 400
if 'definition' in request.json:
dashboard.definition = database.DefinitionRecord(
dumps(request.json['definition']))
else:
dashboard.definition = database.DefinitionRecord(
dumps(DashboardDefinition()))
mgr.store_dashboard(dashboard)
href = url_for('api.dashboard_get', id=dashboard.id)
return {
'dashboard_href':
href,
'view_href':
url_for('ui.dashboard_with_slug',
id=dashboard.id,
slug=inflection.parameterize(dashboard.title))
}, 201, {
'Location': href
}
def parameterize(word):
"""Parameterize the word so it can be used as a python or javascript variable name.
For example:
>>> word = "Acme® EV-Charger™"
"acme_ev_chargertm"
"""
return inflection.parameterize(word).replace("-", "_")
def key_to_pv(key: str) -> str:
"""
Take an archiver appliance JSON key and make a PV name out of it.
Parameters
----------
key : str
The archiver appliance metrics key name.
Example
-------
>>> key_to_pv("Avg time spent by getETLStreams() in ETL(0»1) (s/run)")
'AvgTimeSpentByGetetlstreamsInEtl0To1SPerRun'
"""
# Pre-filter: » -> to
key = key.replace("»", " to ")
# Pre-filter: / -> per
key = key.replace("/", " per ")
# Pre-filter: ETL -> _ETL_
key = key.replace("ETL", " ETL ")
# Pre-filter: .*rate -> Rate
if key.endswith('rate'):
key = key[:-4] + 'Rate'
# Parametrize it for consistency:
parametrized = inflection.parameterize(key)
return inflection.camelize(parametrized.replace("-", "_"))
def load_schema(schema, schemas_store=None):
_("""
Load a schema to the schema store.
if no schema store is provided, only the internal schema store is filled.
:param schema: schema as dictionary
:type schema: dict
:param schemas_store: optional schemas_store to fill
:type schemas_store: dict
""")
from ngoschema.resolvers.uri_resolver import UriResolver
uri = _id_of(schema).rstrip('#')
if not uri and "title" in schema:
uri = inflection.parameterize(six.text_type(schema["title"]), "_")
if not uri:
raise SchemaError(
"Impossible to load schema because `id (or `$id) and `title fields"
"are missing.\n%s" % schema)
if schemas_store is not None:
if schema != schemas_store.get(uri, schema):
logger.info(
"Overwriting a different schema '%s' is already registered in schema store."
% uri)
schemas_store[uri] = schema
# add to main registry
UriResolver.register_doc(schema, uri)
return uri, schema
def fetch_feeds():
for feed_data in feeds:
feed = feedparser.parse(feed_data.get('url'))
items = []
filename = out_filename(parameterize(feed_data.get('name')))
for i in range(0, feed_data.get('count')):
entry = feed['entries'][i]
item = {
'title':
entry['title'],
'description':
feed_data.get(
'parse_description',
parse_description
)(entry),
'alt_text':
feed_data.get('parse_alt', lambda x: '')(entry)
}
items.append(item)
template = Template(
filename=template_path(feed_data.get('layout')))
with open(filename, 'w') as f:
f.write(template.render(items=items))
def on_files(self, files: Files, config: Config):
json_dir = "api"
(pathlib.Path(config['docs_dir']).resolve() / json_dir).mkdir(
parents=True, exist_ok=True)
(pathlib.Path(config['site_dir']).resolve() / json_dir).mkdir(
parents=True, exist_ok=True)
all_json_file = File(f"{json_dir}/codes.json", config["docs_dir"],
config["site_dir"], config["use_directory_urls"])
with open(all_json_file.abs_src_path, "w") as file:
json.dump(self.codes, file, indent=2)
with open(all_json_file.abs_dest_path, "w") as file:
json.dump(self.codes, file, indent=2)
for category, codes in self.codes_by_category.items():
dir = parameterize(f"{category}-responses")
for name, emojicode in codes.items():
md_file = File(f"{dir}/{name}.md", config["docs_dir"],
config["site_dir"],
config["use_directory_urls"])
files.append(md_file)
json_file = File(f"{json_dir}/{name}.json", config["docs_dir"],
config["site_dir"],
config["use_directory_urls"])
with open(json_file.abs_src_path, "w") as file:
json.dump(emojicode, file, indent=2)
files.append(json_file)
def from_value(cls, value):
try:
actual = value["value"]
except TypeError:
actual = value
alias = inflection.parameterize(str(actual), "-")
except KeyError:
raise TypeError(
"Expected a value or a mapping with a `value` key.")
else:
try:
alias = value["alias"]
except KeyError:
alias = inflection.parameterize(str(actual), "-")
return cls(alias=alias, value=actual)
def parse_column_name(column_name):
if column_name == 'ID':
return 'legacyId'
if column_name == 'Reference Id':
return 'referenceId'
if isinstance(column_name, int):
key = f"column-{column_name}"
elif isinstance(column_name, str):
# key = unidecode(column_name)
key = column_name.replace('-&-', '-and-')
key = key.replace('&', ' and ')
# print(f"key={key} is_camel_case={is_lower_camel_case(key)}")
if not is_lower_camel_case(key):
key = inflection.parameterize(key)
if not is_lower_camel_case(key):
key = case(key)
elif isinstance(column_name, Timestamp):
key = f"column-{Literal(column_name).lower()}"
else:
error(f"Encountered unknown type {type(column_name)} for value {column_name}")
return None
key = key.replace(' ', ' ')
key = key.replace('--', '-')
key = key.replace('--', '-')
key = strip_end(key, '-')
return key
def get_file_context(self, **kwargs):
get_framework_and_lot(
kwargs['framework_slug'],
kwargs['lot_slug'],
self.data_api_client,
allowed_statuses=['live', 'expired'],
must_allow_brief=True,
)
brief = self.data_api_client.get_brief(kwargs['brief_id'])["briefs"]
if not is_brief_correct(brief, kwargs['framework_slug'],
kwargs['lot_slug'], current_user.id):
abort(404)
if brief['status'] not in CLOSED_PUBLISHED_BRIEF_STATUSES:
abort(404)
file_context = {
'brief':
brief,
'responses':
self.get_responses(brief),
'filename':
'supplier-responses-{0}'.format(
inflection.parameterize(str(brief['title']))),
}
return file_context
def __init__(self, field):
self.field = field
# Try to name this XSD type
# Note: should we use field.context.key ?
# The problem is that when dealing with List/Dict fields, the value_type
# field also inherits the parent's context
name = field.getName() or str(inflection.parameterize(field.title))
if not name:
try:
name = field.getTaggedValue("name")
except KeyError:
pass
assert name, "The field should be named"
name = inflection.underscore(name)
self.typename = inflection.camelize(name)
self.name = inflection.dasherize(name)
# Compute occurence indicators
self.min_occurs = 1 if field.required else 0
self.max_occurs = 1
def parse_mouse_info(df: pd.DataFrame, study_id: int, ordinal_value: int):
mouse_schema = Mouse.Schema(unknown=EXCLUDE)
try:
df.columns = map(lambda x: underscore(parameterize(x)), df.columns)
except Exception as e:
raise HeaderException(df, msg=str(e))
for col in ['euthanasia_date', 'injection_date']:
try:
df[col] = pd.to_datetime(df[col])
except Exception as e:
raise ColumnException(df=df, col=col, msg=str(e), hide_index=True)
for _, row in df.iterrows():
try:
row_dict = row.to_dict()
row_dict = timestamp_to_db_date(row_dict)
row_dict['ordinal_value'] = ordinal_value
ordinal_value += 1
mouse = mouse_schema.load(row_dict)
mouse.study_id = study_id
mouse.save()
except Exception as e:
raise RowException(df=df, msg=str(e), row=str(_), hide_index=True)
print("MOUSE INFO PARSED")
return ordinal_value
def _add_enums(root_object, target_object):
"""
Look for enums in the given object to create string constants <ENUM_CLASSNAME>_<ENUM_VALUE>.
:param dict root_object: the object which may contain enums
:param object target_object: The target object where to add the string constants to
"""
for i in root_object.keys():
enum = None
propinfo = root_object.propinfo(i)
if 'enum' in propinfo:
enum = propinfo
if propinfo['type'] == 'array':
if 'enum' in propinfo['items']:
enum = propinfo['items']
if not enum:
continue
enum_class = str(i).upper()
if 'title' in enum:
enum_class = str(inflection.underscore(enum['title'])).upper()
enum_class += "_"
for val in enum['enum']:
enum_value = enum_class + inflection.parameterize(val, '_').upper()
setattr(target_object, enum_value, val)
def format_workflow(s):
s = re.sub(r"[_-]", " ", s) # convert underscores to spaces
s = re.sub(r"([A-Z]+)", r" \1", s) # convert camel case into words
s = _replace_special(s)
return underscore(parameterize(s))
def teams_add():
if request.mimetype != 'application/json':
abort(415)
data = team_schema(request.json)
name = data['name']
original_slug = parameterize(name[:20])
slug = _generate_slug(original_slug)
while Team.query.filter_by(slug=slug).count() > 0:
slug = _generate_slug(original_slug)
team = Team(name=name, slug=slug)
db.session.add(team)
TeamMembership(
team=team,
user=current_identity,
is_admin=True
)
db.session.add(TabType(name='Beer', price=1, team=team))
db.session.add(TabType(name='Cider', price=2, team=team))
db.session.add(Person(name=current_identity.name, team=team))
db.session.commit()
response = _get_teams_response()
response.status_code = 201
return response
def __init__(self, form):
"""
:param self.report_dict: a mapping of form attributes to inputted values
:type self.report_dict: Dict
:param form: report being parsed and saved
:type form: ReportForm
"""
self.form = form
self.format_emails()
self.report_dict["report_title"] = self.form.report_title.data
self.report_dict["report_title_id"] = parameterize(
self.form.report_title.data)
self.report_dict["description"] = self.form.description.data
self.report_dict["owner_name"] = self.form.owner_name.data
self.report_dict["owner_email"] = self.form.owner_email.data
self.report_dict["tests"] = self.form.tests.data
self.report_dict["schedule_type"] = self.form.schedule_type.data
self.report_dict[
"schedule_timezone"] = self.form.schedule_timezone.data
if self.report_dict["schedule_type"] == "custom":
self.report_dict["schedule"] = self.form.schedule_custom.data
elif self.report_dict["schedule_type"] == "manual":
self.report_dict["schedule"] = None
else:
utc_week_day, utc_time = self.get_utc_time_and_week_day()
self.report_dict["schedule_time"] = utc_time
if self.report_dict["schedule_type"] == "weekly":
self.report_dict["schedule_week_day"] = utc_week_day
self.report_dict["schedule"] = self.get_cron_schedule()
def parse_stats_table(table):
"""Parses a table of player's statistics."""
header_elements = [
underscore(parameterize(header))
for header in table.css("th::text").getall() +
table.css("th > span::attr(title)").getall()
]
# for some reason, sometimes transfermarket might call the matchday as spieltag
# here we make sure that if that's the case we revert it back to matchday
header_elements = [
header if header != 'spieltag' else 'matchday'
for header in header_elements
]
value_elements_matrix = [
[
parse_stats_elem(element) for element in row.xpath('td')
if parse_stats_elem(element) is not None
] for row in table.css('tr') if len(row.css('td').getall()) >
9 # TODO: find a way to include 'on the bench' and 'not in squad' occurrences
]
for value_elements in value_elements_matrix:
header_elements_len = len(header_elements)
value_elements_len = len(value_elements)
assert (
header_elements_len == value_elements_len
), f"Header ({header_elements}) - cell element ({value_elements}) mismatch at {response.url}"
yield dict(zip(header_elements, value_elements))
def process(self):
soup = BeautifulSoup(unicode(self.input_data), self.setting('html-parser'))
for tag in soup.find_all(re.compile("^h[0-6]")):
name = tag.text
m = re.match("^h([0-6])$", tag.name)
if not tag.attrs.has_key('id'):
tag.attrs['id'] = inflection.parameterize(name)
self.current_section_anchor = tag.attrs['id']
self.current_section_text = None
self.current_section_name = name
self.current_section_level = int(m.groups()[0])
self.append_current_section()
self.current_section_text = unicode(soup)
self.current_section_name = self.setting('initial-section-name')
self.current_section_level = 1
self.current_section_anchor = None
self.append_current_section()
self.output_data.save()
def cashiers(cashier_ids=None):
if not cashier_ids: print USAGE; return
init_command()
accounts = AccountService()
cash = CashPaymentService()
dates = [ datetime.strptime(d,DATE_FORMAT) for d in config.EVENT_DATES ]
cashiers = [ accounts.get_one(c,check_ownership=False) for c in cashier_ids.split(",") ]
for cashier in cashiers:
filename = "report_{}.ods".format(parameterize(cashier.name))
with ods.writer(open(filename,"wb")) as odsfile:
for date in dates:
sheet = odsfile.new_sheet(date.strftime("dia %d"))
sheet.writerow(["hora","modo","valor","id","nome","produto"])
report = cash.for_cashier(cashier, date)
for payment in report:
person = Person(payment.purchase)
for transition in payment.transitions:
row = [
transition.created.time(), transition.mode, Decimal(payment.amount),
person.id, person.name, person.product.description
]
sheet.writerow(row)
summer = lambda f: sum([ x.amount for x in filter(f, report) ])
sheet.writerow([None, u"total cartão", summer(lambda p: p.mode == 'card') ])
sheet.writerow([None, u"total dinheiro", summer(lambda p: p.mode == 'cash') ])
sheet.writerow([None, u"total geral", summer(lambda p: True ) ])
def build_classes(self,strict=False):
"""
Args:
strict: use this to validate required fields while creating the class
Returns:
"""
builder = classbuilder.ClassBuilder(self.resolver)
for nm, defn in iteritems(self.schema.get('definitions', {})):
uri = util.resolve_ref_uri(
self.resolver.resolution_scope,
"#/definitions/" + nm)
builder.construct(uri, defn)
nm = self.schema['title'] if 'title' in self.schema else self.schema['id']
nm = inflection.parameterize(six.text_type(nm), '_')
kw = {"strict" : strict}
builder.construct(nm, self.schema,**kw)
self._resolved = builder.resolved
return (
util.Namespace.from_mapping(dict(
(inflection.camelize(uri.split('/')[-1]),
klass) for uri,
klass in six.iteritems(builder.resolved)))
)
def _add_enums(root_object, target_object):
"""
Look for enums in the given object to create string constants <ENUM_CLASSNAME>_<ENUM_VALUE>.
:param dict root_object: the object which may contain enums
:param object target_object: The target object where to add the string constants to
"""
for i in root_object.keys():
enum = None
propinfo = root_object.propinfo(i)
if 'enum' in propinfo:
enum = propinfo
if propinfo['type'] == 'array':
if 'enum' in propinfo['items']:
enum = propinfo['items']
if not enum:
continue
enum_class = str(i).upper()
if 'title' in enum:
enum_class = str(inflection.underscore(enum['title'])).upper()
enum_class += "_"
for val in enum['enum']:
enum_value = enum_class + inflection.parameterize(val, '_').upper()
setattr(target_object, enum_value, val)
def linkify(text: str):
"""
Replaces all non alphanum characters with '-' and lowercases
everything.
"foo: bar baz st. claire" => "foo-bar-baz-st-claire"
use: {{ "Foo Bar Baz St. Claire"|linkify }}
"""
return inflection.parameterize(text)
def format_brand(brand_value):
"Make universal format"
try:
brand = parameterize(brand_value, '_')
except:
brand = ''
return brand
def export_dashboard(self, dashboard, directory):
filepath = '{0}/{1}.json'.format(directory, inflection.parameterize(dashboard.category + ' ' + dashboard.title))
log.info('Exporting to {0}'.format(filepath))
f = open(filepath, 'w')
try:
json.dump(dashboard, f, indent=2, cls=EntityEncoder)
finally:
f.close()
def convert_tag(self, tag):
tag = tag.strip()
if not self.tags:
url = urljoin(self.base_url, 'wp/v2/tags?per_page=100')
r = self.oauth.get(url)
for item in r.json():
self.tags[item['slug']] = item['id']
if parameterize(tag) in self.tags:
return self.tags[parameterize(tag)]
else:
post_url = urljoin(self.base_url, 'wp/v2/tags')
new_tag = {'name': tag, 'slug': parameterize(tag)}
r = self.oauth.post(post_url, json=new_tag).json()
self.tags[r['slug']] = r['id']
print('*** Make new tag: %s ***' % tag)
print(r)
return r['id']
def branch_name(self) -> str:
"""
Get the branch name from ID and title.
>>> Issue(id='jir-123', summary='Update readme.md file').branch_name()
jir-123-update-readme-file
"""
return inflection.parameterize(f"{self._id} {self._summary}")
def test_parameterize_with_multi_character_separator(
some_string,
parameterized_string
):
assert (
parameterized_string.replace('-', '__sep__') ==
inflection.parameterize(some_string, '__sep__')
)
def process_worksheet(gsheets_loader, sheet_name, worksheet, start_from_row, config):
if worksheet is None:
name_with_worksheet = sheet_name
else:
name_with_worksheet = sheet_name + "_" + worksheet
if 'singular_table_name' in config and config['singular_table_name']:
stream_name = underscore(parameterize(name_with_worksheet))
else:
stream_name = tableize(parameterize(name_with_worksheet))
schema = gsheets_loader.get_schema(sheet_name, worksheet, start_from_row)
records = gsheets_loader.get_records_as_json(sheet_name, worksheet, start_from_row)
# additional data transformations
column_mapping = None
if 'underscore_columns' in config and config['underscore_columns']:
column_mapping = {'id': 'id'}
props = {}
for k, v in schema['properties'].items():
kt = underscore(parameterize(k))
props[kt] = v
column_mapping[k] = kt
schema['properties'] = props
schema['properties']['id'] = {'type': 'integer'}
for i, record in enumerate(records, start=1):
record['id'] = i
# write stuff
singer.write_schema(
stream_name=stream_name,
schema=schema,
key_properties=['id']
)
for record in records:
if column_mapping is not None:
record_transformed = {column_mapping[k]: v for k, v in record.items()}
else:
record_transformed = record
singer.write_record(stream_name, record_transformed)
def to_snake_case(name: str):
"""Make any string into a "snake_cased" string.
Args:
name (str): The name to convert.
Returns:
str: The converted string.
"""
return inflection.parameterize(inflection.titleize(name), separator="_").lower()
def export_dashboard(dashboard, directory):
dash = dashboard.to_json()
dash['definition'] = json.loads(dashboard.definition.definition)
filepath = '{0}/{1}.json'.format(directory, inflection.parameterize(dashboard.category + ' ' + dashboard.title))
log.info('Exporting to {0}'.format(filepath))
f = open(filepath, 'w')
try:
json.dump(dash, f, indent=2, cls=web.EntityEncoder)
finally:
f.close()
def save_author_data(author, data, output_path):
flip_name = '_'.join(reversed(parameterize(author).split('-')))
file_name = '{}.json'.format(flip_name)
file_path = '{output_path}/{file_name}'.format(
output_path=output_path, file_name=file_name)
with open(file_path, 'w') as file:
file.write(json.dumps(data))
print('Saved {} to disk'.format(author))
def _set_dashboard_hrefs(dash):
"""Add the various ReSTful hrefs to an outgoing dashboard
representation. dash should be the dictionary for of the dashboard,
not the model object.
"""
id = dash['id']
dash['href'] = '/api/dashboard/{0}'.format(id)
dash['definition_href'] = '/api/dashboard/{0}/definition'.format(id)
dash['view_href'] = '/dashboards/{0}/{1}'.format(id, inflection.parameterize(dash['title']))
if 'definition' in dash:
definition = dash['definition']
definition['href'] = '/api/dashboard/{0}/definition'.format(id)
return dash
def run():
h2 = Helper2()
owner, repo = h2.owner_and_repo()
api = GithubAPIGateway(owner, repo, token=os.environ['GITHUB_TOKEN'])
issue = None
if len(sys.argv) <= 1:
issue = api.call('list_issues', org=owner)[0][0]
else:
issue = api.call('list_issue', owner=owner, repo=repo, number=sys.argv[1])[0]
branch_name = str(issue['number']) + '-' + inflection.parameterize(issue['title'])[:30].strip('-')
result = h2.create_branch(branch_name)
if result[0] != 0:
print(result[1])
sys.exit(result[0])
def _set_dashboard_hrefs(dash):
"""Add the various ReSTful hrefs to an outgoing dashboard
representation. dash should be the dictionary for of the dashboard,
not the model object.
"""
id = dash['id']
dash['href'] = url_for('api_dashboard_get', id=id)
dash['definition_href'] = url_for('api_dashboard_get_definition', id=id)
dash['view_href'] = url_for('ui_dashboard_with_slug',
id=id,
slug=inflection.parameterize(dash['title']))
if 'definition' in dash:
definition = dash['definition']
definition['href'] = url_for('api_dashboard_get_definition', id=id)
return dash
def api_dashboard_create():
"""Create a new dashboard with an empty definition.
"""
dashboard = database.DashboardRecord.from_json(request.json)
if 'definition' in request.json:
dashboard.definition = database.DefinitionRecord(dumps(request.json['definition']))
else:
dashboard.definition = database.DefinitionRecord(dumps(DashboardDefinition()))
mgr.store_dashboard(dashboard)
href = '/api/dashboard/{0}'.format(dashboard.id)
return _jsonify({
'dashboard_href' : href,
# TODO: should use normalized method for this
'view_href' : '/dashboards/{0}/{1}'.format(dashboard.id, inflection.parameterize(dashboard.title))
}, status=201, headers = { 'Location' : href })
def api_dashboard_create():
"""Create a new dashboard with an empty definition.
"""
dashboard = database.DashboardRecord.from_json(request.json)
if 'definition' in request.json:
dashboard.definition = database.DefinitionRecord(dumps(request.json['definition']))
else:
dashboard.definition = database.DefinitionRecord(dumps(DashboardDefinition()))
mgr.store_dashboard(dashboard)
href = url_for('api_dashboard_get', id=dashboard.id)
return _jsonify({
'dashboard_href' : href,
'view_href' : url_for('ui_dashboard_with_slug',
id=dashboard.id,
slug=inflection.parameterize(dashboard.title))
}, status=201, headers = { 'Location' : href })
def build_classes(self):
builder = classbuilder.ClassBuilder(self.resolver)
for nm, defn in iteritems(self.schema.get('definitions', {})):
uri = util.resolve_ref_uri(
self.resolver.resolution_scope,
"#/definitions/" + nm)
builder.construct(uri, defn)
nm = self.schema['title'] if 'title' in self.schema else self.schema['id']
nm = inflection.parameterize(six.text_type(nm), '_')
builder.construct(nm, self.schema)
return (
util.Namespace.from_mapping(dict(
(inflection.camelize(uri.split('/')[-1]),
klass) for uri,
klass in six.iteritems(builder.resolved)))
)
def dashboard_create():
"""Create a new dashboard with an empty definition.
"""
dashboard = database.DashboardRecord.from_json(request.json)
if not dashboard.title:
return {
'error_message': "Missing required field 'title'"
}, 400
if 'definition' in request.json:
dashboard.definition = database.DefinitionRecord(dumps(request.json['definition']))
else:
dashboard.definition = database.DefinitionRecord(dumps(DashboardDefinition()))
mgr.store_dashboard(dashboard)
href = url_for('api.dashboard_get', id=dashboard.id)
return {
'dashboard_href' : href,
'view_href' : url_for('ui.dashboard_with_slug',
id=dashboard.id,
slug=inflection.parameterize(dashboard.title))
}, 201, { 'Location' : href }
def __convert(self, graphite_dashboard, dash=None, layout=Section.Layout.FIXED, columns=2, overwrite=False):
span = 12 / columns
name = graphite_dashboard['name']
dashboard = dash
if dashboard is None:
dashboard = Dashboard(title=inflection.parameterize(name),
category='Graphite',
tags=['imported'],
imported_from=self.__graphite_href(name))
definition = DashboardDefinition()
section = Section(layout=layout)
definition.items.append(section)
# if 'defaultGraphParams' in graphite_dashboard:
# default_width = graphite_dashboard['defaultGraphParams'].get('width', None)
# print graphite_dashboard['defaultGraphParams']
# if default_width and default_width > 800:
# num_columns = 1
# span = 12
graph_count = 0
row = Row()
for graph in graphite_dashboard['graphs']:
# Graphite's dashboard API is so redundant. Each graph is
# a 3-element array:
# [
# target string,
# options dict (which contains the targets array too),
# render URL string
# ]
targets, options, render_url = graph
presentation = None
stacked_p = (render_url.find('stacked')) != -1 or (options.get('areaMode', None) == 'stacked')
query = 'q' + str(len(definition.queries))
targets = options.get('target', [])
definition.queries[query] = targets[0] if len(targets) == 1 else targets
if stacked_p:
presentation = StackedAreaChart(query=query, title=options.get('title', ''))
else:
presentation = StandardTimeSeries(query=query, title=options.get('title', ''))
presentation.options['yAxisFormat'] = ',.2s'
presentation.height = 4
if 'template' in options:
presentation.options['palette'] = options['template']
if 'vtitle' in options:
presentation.options['yAxisLabel'] = options['vtitle']
presentation.options['yShowMaxMin'] = True
presentation.options['margin'] = { 'top' : 16, 'left' : 80, 'right' : 0, 'bottom' : 16 }
presentation.options['y1'] = {'max' : options.get('yMax', ''), 'min' : options.get('yMin', ''), 'label' : options.get('vtitle', '')}
row.items.append(Cell(span=span, items=presentation))
graph_count += 1
if len(row.items) == columns:
section.items.append(row)
row = Row()
if len(row.items) > 0:
section.items.append(row)
if graph_count == 0:
log.warn('Failed to convert any graphs for dashboard {0}'.format(name))
dashboard.definition = definition
return dashboard
def methodize(string):
return parameterize(string.replace(r'.', '')).replace(r'-', '_')
def url_word(word: str):
"""
Normalizes a full word to be inserted to an url. If the word has spaces, etc, is used '_' and not '-'
"""
return inflection.parameterize(word, "_")
def test_parameterize_with_no_separator(some_string, parameterized_string):
assert parameterized_string == inflection.parameterize(some_string, '')
def __convert(self, graphite_dashboard, dash=None, layout=Section.Layout.FIXED, columns=2, overwrite=False):
span = 12 / columns
name = graphite_dashboard["name"]
dashboard = dash
if dashboard is None:
dashboard = Dashboard(
title=inflection.parameterize(name),
category="Graphite",
tags=["imported"],
imported_from=self.__graphite_href(name),
)
definition = DashboardDefinition()
section = Section(layout=layout)
definition.items.append(section)
# if 'defaultGraphParams' in graphite_dashboard:
# default_width = graphite_dashboard['defaultGraphParams'].get('width', None)
# print graphite_dashboard['defaultGraphParams']
# if default_width and default_width > 800:
# num_columns = 1
# span = 12
graph_count = 0
row = Row()
for graph in graphite_dashboard["graphs"]:
# Graphite's dashboard API is so redundant. Each graph is
# a 3-element array:
# [
# target string,
# options dict (which contains the targets array too),
# render URL string
# ]
targets, options, render_url = graph
presentation = None
stacked_p = (render_url.find("stacked")) != -1 or (options.get("areaMode", None) == "stacked")
query = "q" + str(len(definition.queries))
targets = options.get("target", [])
definition.queries[query] = targets[0] if len(targets) == 1 else targets
if stacked_p:
presentation = StackedAreaChart(query=query, title=options.get("title", ""))
else:
presentation = StandardTimeSeries(query=query, title=options.get("title", ""))
presentation.options["yAxisFormat"] = ",.2s"
presentation.height = 4
if "template" in options:
presentation.options["palette"] = options["template"]
if "vtitle" in options:
presentation.options["yAxisLabel"] = options["vtitle"]
presentation.options["yShowMaxMin"] = True
presentation.options["margin"] = {"top": 16, "left": 80, "right": 0, "bottom": 16}
presentation.options["y1"] = {
"max": options.get("yMax", ""),
"min": options.get("yMin", ""),
"label": options.get("vtitle", ""),
}
row.items.append(Cell(span=span, items=presentation))
graph_count += 1
if len(row.items) == columns:
section.items.append(row)
row = Row()
if len(row.items) > 0:
section.items.append(row)
if graph_count == 0:
log.warn("Failed to convert any graphs for dashboard {0}".format(name))
dashboard.definition = definition
return dashboard
def filter_methodize(token):
if token is None:
return None
return underscore(parameterize(underscore(token)))
def get_fields(self):
self.raw_fields = self.make_request(self.url + self.ENDPOINTS['fields'])
self.fields = [Field(field) for field in self.raw_fields['fields']]
self.fields = {inflection.parameterize(field.label, "_"): field for field in self.fields}
return self.fields
def filter_objectize(token):
if token is None:
return None
return camelize(underscore(parameterize(underscore(token))))
def to_url(self, value):
raw = str(value) if self.attr is None else getattr(value, self.attr, '')
slug = parameterize(raw)[:self.length].rstrip('-')
return '{}/{}'.format(value.id, slug).rstrip('/')
def parameterize(self, separator='-'):
return inflection.parameterize(self.__str__(), separator)
def test_parameterize_and_normalize(some_string, parameterized_string):
assert parameterized_string == inflection.parameterize(some_string)
def filter_variablize(token):
if token is None:
return None
return underscore(parameterize(underscore(token)))
def create_id(name):
return inflection.parameterize(name)
