lib/xos-genx/xosgenx/jinja2_extensions/django.py - xos - Gitiles

 # Copyright 2017-present Open Networking Foundation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 # http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.


 from base import *
 import pdb
 import re


 def django_content_type_string(xptags):
     # Check possibility of KeyError in caller
     content_type = xptags["content_type"]

     try:
         content_type = eval(content_type)
     except BaseException:
         pass

     if content_type == "url":
         return "URLField"
     if content_type == "date":
         return "DateTimeField"
     elif content_type == "ip":
         return "GenericIPAddressField"
     elif content_type == "stripped" or content_type == '"stripped"':
         return "StrippedCharField"
     else:
         raise Exception("Unknown Type: %s" % content_type)


 def django_string_type(xptags):
     try:
         max_length = eval(xptags["max_length"])
     except BaseException:
         max_length = 1024 * 1024

     if "content_type" in xptags:
         return django_content_type_string(xptags)
     elif max_length < 1024 * 1024:
         return "CharField"
     else:
         return "TextField"


 def xproto_django_type(xptype, xptags):
     if xptype == "string":
         return django_string_type(xptags)
     elif xptype == "float":
         return "FloatField"
     elif xptype == "bool":
         return "BooleanField"
     elif xptype == "uint32":
         return "IntegerField"
     elif xptype == "int32":
         return "IntegerField"
     elif xptype == "int64":
         return "BigIntegerField"
     else:
         raise Exception("Unknown Type: %s" % xptype)


 def xproto_django_link_type(f):
     if f["link_type"] == "manytoone":
         return "ForeignKey"
     elif f["link_type"] == "onetoone":
         return "OneToOneField"
     elif f["link_type"] == "manytomany":
         if f["dst_port"]:
             return "ManyToManyField"
         else:
             return "GenericRelation"


 def map_xproto_to_django(f):
     allowed_keys = [
         "help_text",
         "default",
         "max_length",
         "modifier",
         "blank",
         "choices",
         "db_index",
         "null",
         "editable",
         "on_delete",
         "verbose_name",
         "auto_now_add",
         "unique",
         "min_value",
         "max_value",
     ]

     if f.get("link_type") == "manytomany":
         # map for fields that do not support null
         m = {
             "modifier": {"optional": True, "required": False, "_targets": ["blank"]}
         }
     else:
         # map for fields that do support null
         # TODO evaluate if setting Null = False for all strings
         m = {
             "modifier": {"optional": True, "required": False, "_targets": ["null", "blank"]}
         }

     out = {}

     for k, v in f["options"].items():
         if k in allowed_keys:
             try:
                 # NOTE this will be used to parse xproto optional/required field prefix
                 # and apply it to the null and blank fields
                 kv2 = m[k]
                 for t in kv2["_targets"]:
                     out[t] = kv2[v]
             except BaseException:
                 out[k] = v

     return out


 def xproto_django_link_options_str(field, dport=None):
     # Note that this function is called for links (ForeignKeys, M2Ms)

     output_dict = map_xproto_to_django(field)

     if dport and (dport == "+" or "+" not in dport):
         output_dict["related_name"] = "%r" % dport

     try:
         if field["through"]:
             d = {}
             if isinstance(field["through"], str):
                 split = field["through"].rsplit(".", 1)
                 d["name"] = split[-1]
                 if len(split) == 2:
                     d["package"] = split[0]
                     d["fqn"] = "package" + "." + d["name"]
                 else:
                     d["fqn"] = d["name"]
                     d["package"] = ""
             else:
                 d = field["through"]

             if not d["name"].endswith("_" + field["name"]):
                 output_dict["through"] = "%r" % d["fqn"]
     except KeyError:
         pass

     return format_options_string(output_dict)


 def use_native_django_validators(k, v):

     validators_map = {
         "min_value": "MinValueValidator",
         "max_value": "MaxValueValidator",
     }

     return "%s(%s)" % (validators_map[k], v)


 def format_options_string(d):

     known_validators = ["min_value", "max_value"]
     validator_lst = []

     if not d:
         return ""
     else:

         lst = []
         for k, v in d.items():
             if k in known_validators:
                 validator_lst.append(use_native_django_validators(k, v))
             elif isinstance(v, str) and k == "default" and v.endswith('()"'):
                 lst.append("%s = %s" % (k, v[1:-3]))
             elif isinstance(v, str) and v.startswith('"'):
                 try:
                     # unquote the value if necessary
                     tup = eval(v[1:-1])
                     if isinstance(tup, tuple):
                         lst.append("%s = %r" % (k, tup))
                     else:
                         lst.append("%s = %s" % (k, v))
                 except BaseException:
                     lst.append("%s = %s" % (k, v))
             elif isinstance(v, bool):
                 lst.append("%s = %r" % (k, bool(v)))
             else:
                 try:
                     lst.append("%s = %r" % (k, int(v)))
                 except ValueError:
                     lst.append("%s = %s" % (k, v))
         validator_string = "validators=[%s]" % ", ".join(validator_lst)
         option_string = ", ".join(lst)
         if len(validator_lst) == 0:
             return option_string
         elif len(lst) == 0:
             return validator_string
         else:
             return option_string + ", " + validator_string


 def xproto_django_options_str(field, dport=None):
     # This function is called for non-links (Strings, Ints, Booleans, ...)

     output_dict = map_xproto_to_django(field)

     if dport == "_":
         dport = "+"

     if dport and (dport == "+" or "+" not in dport):
         output_dict["related_name"] = "%r" % dport

     return format_options_string(output_dict)


 def xproto_camel_to_underscore(name):
     return re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)


 def xproto_validations(options):
     try:
         return [
             map(str.strip, validation.split(":"))
             for validation in unquote(options["validators"]).split(",")
         ]
     except KeyError:
         return []


 def xproto_optioned_fields_to_list(fields, option, val):
     """
     List all the field that have a particural option
     :param fields: (list) an array of message fields
     :param option: (string) the option to look for
     :param val: (any) the value of the option
     :return: list of strings, field names where option is set
     """

     optioned_fields = []
     for f in fields:
         option_names = []
         for k, v in f["options"].items():
             option_names.append(k)

         if option in option_names and f["options"][option] == val:
             optioned_fields.append(f["name"])

     return optioned_fields


 # TODO
 # - in modeldefs add info about this fields
 # - update the gui to have this fields as readonly
	# Copyright 2017-present Open Networking Foundation
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.


	from base import *
	import pdb
	import re


	def django_content_type_string(xptags):
	# Check possibility of KeyError in caller
	content_type = xptags["content_type"]

	try:
	content_type = eval(content_type)
	except BaseException:
	pass

	if content_type == "url":
	return "URLField"
	if content_type == "date":
	return "DateTimeField"
	elif content_type == "ip":
	return "GenericIPAddressField"
	elif content_type == "stripped" or content_type == '"stripped"':
	return "StrippedCharField"
	else:
	raise Exception("Unknown Type: %s" % content_type)


	def django_string_type(xptags):
	try:
	max_length = eval(xptags["max_length"])
	except BaseException:
	max_length = 1024 * 1024

	if "content_type" in xptags:
	return django_content_type_string(xptags)
	elif max_length < 1024 * 1024:
	return "CharField"
	else:
	return "TextField"


	def xproto_django_type(xptype, xptags):
	if xptype == "string":
	return django_string_type(xptags)
	elif xptype == "float":
	return "FloatField"
	elif xptype == "bool":
	return "BooleanField"
	elif xptype == "uint32":
	return "IntegerField"
	elif xptype == "int32":
	return "IntegerField"
	elif xptype == "int64":
	return "BigIntegerField"
	else:
	raise Exception("Unknown Type: %s" % xptype)


	def xproto_django_link_type(f):
	if f["link_type"] == "manytoone":
	return "ForeignKey"
	elif f["link_type"] == "onetoone":
	return "OneToOneField"
	elif f["link_type"] == "manytomany":
	if f["dst_port"]:
	return "ManyToManyField"
	else:
	return "GenericRelation"


	def map_xproto_to_django(f):
	allowed_keys = [
	"help_text",
	"default",
	"max_length",
	"modifier",
	"blank",
	"choices",
	"db_index",
	"null",
	"editable",
	"on_delete",
	"verbose_name",
	"auto_now_add",
	"unique",
	"min_value",
	"max_value",
	]

	if f.get("link_type") == "manytomany":
	# map for fields that do not support null
	m = {
	"modifier": {"optional": True, "required": False, "_targets": ["blank"]}
	}
	else:
	# map for fields that do support null
	# TODO evaluate if setting Null = False for all strings
	m = {
	"modifier": {"optional": True, "required": False, "_targets": ["null", "blank"]}
	}

	out = {}

	for k, v in f["options"].items():
	if k in allowed_keys:
	try:
	# NOTE this will be used to parse xproto optional/required field prefix
	# and apply it to the null and blank fields
	kv2 = m[k]
	for t in kv2["_targets"]:
	out[t] = kv2[v]
	except BaseException:
	out[k] = v

	return out


	def xproto_django_link_options_str(field, dport=None):
	# Note that this function is called for links (ForeignKeys, M2Ms)

	output_dict = map_xproto_to_django(field)

	if dport and (dport == "+" or "+" not in dport):
	output_dict["related_name"] = "%r" % dport

	try:
	if field["through"]:
	d = {}
	if isinstance(field["through"], str):
	split = field["through"].rsplit(".", 1)
	d["name"] = split[-1]
	if len(split) == 2:
	d["package"] = split[0]
	d["fqn"] = "package" + "." + d["name"]
	else:
	d["fqn"] = d["name"]
	d["package"] = ""
	else:
	d = field["through"]

	if not d["name"].endswith("_" + field["name"]):
	output_dict["through"] = "%r" % d["fqn"]
	except KeyError:
	pass

	return format_options_string(output_dict)


	def use_native_django_validators(k, v):

	validators_map = {
	"min_value": "MinValueValidator",
	"max_value": "MaxValueValidator",
	}

	return "%s(%s)" % (validators_map[k], v)


	def format_options_string(d):

	known_validators = ["min_value", "max_value"]
	validator_lst = []

	if not d:
	return ""
	else:

	lst = []
	for k, v in d.items():
	if k in known_validators:
	validator_lst.append(use_native_django_validators(k, v))
	elif isinstance(v, str) and k == "default" and v.endswith('()"'):
	lst.append("%s = %s" % (k, v[1:-3]))
	elif isinstance(v, str) and v.startswith('"'):
	try:
	# unquote the value if necessary
	tup = eval(v[1:-1])
	if isinstance(tup, tuple):
	lst.append("%s = %r" % (k, tup))
	else:
	lst.append("%s = %s" % (k, v))
	except BaseException:
	lst.append("%s = %s" % (k, v))
	elif isinstance(v, bool):
	lst.append("%s = %r" % (k, bool(v)))
	else:
	try:
	lst.append("%s = %r" % (k, int(v)))
	except ValueError:
	lst.append("%s = %s" % (k, v))
	validator_string = "validators=[%s]" % ", ".join(validator_lst)
	option_string = ", ".join(lst)
	if len(validator_lst) == 0:
	return option_string
	elif len(lst) == 0:
	return validator_string
	else:
	return option_string + ", " + validator_string


	def xproto_django_options_str(field, dport=None):
	# This function is called for non-links (Strings, Ints, Booleans, ...)

	output_dict = map_xproto_to_django(field)

	if dport == "_":
	dport = "+"

	if dport and (dport == "+" or "+" not in dport):
	output_dict["related_name"] = "%r" % dport

	return format_options_string(output_dict)


	def xproto_camel_to_underscore(name):
	return re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)


	def xproto_validations(options):
	try:
	return [
	map(str.strip, validation.split(":"))
	for validation in unquote(options["validators"]).split(",")
	]
	except KeyError:
	return []


	def xproto_optioned_fields_to_list(fields, option, val):
	"""
	List all the field that have a particural option
	:param fields: (list) an array of message fields
	:param option: (string) the option to look for
	:param val: (any) the value of the option
	:return: list of strings, field names where option is set
	"""

	optioned_fields = []
	for f in fields:
	option_names = []
	for k, v in f["options"].items():
	option_names.append(k)

	if option in option_names and f["options"][option] == val:
	optioned_fields.append(f["name"])

	return optioned_fields


	# TODO
	# - in modeldefs add info about this fields
	# - update the gui to have this fields as readonly