def generate_constructor(self, schemas, indentation, is_property=False):
constructor_params = [" " * indentation + "def __init__(self"]
ignore = [p for p in TO_EXCLUDE]
for schema in schemas:
for prop_name, prop in self._get_schema_properties(schema).items():
prop_name = utils.to_snake_case(prop_name)
req = " = None" # TODO: check if prop is required or not
if prop_name not in ignore:
constructor_params.append("{}: {}{}".format(prop_name, self._get_type_hint(prop), req))
ignore.append(prop_name)
if is_property:
constructor_params.append("**kwargs")
else:
constructor_params.append("cognite_client = None")
constructor_params = ", ".join(constructor_params) + "):"
constructor_body = ""
ignore = [p for p in TO_EXCLUDE]
for schema in schemas:
for prop_name, prop in self._get_schema_properties(schema).items():
prop_name = utils.to_snake_case(prop_name)
if prop_name not in ignore:
constructor_body += " " * (indentation + 4) + "self.{} = {}\n".format(prop_name, prop_name)
ignore.append(prop_name)
if is_property:
constructor_body += " " * (indentation + 4) + "self.update(kwargs)\n"
else:
constructor_body += " " * (indentation + 4) + "self._cognite_client = cognite_client\n"
return constructor_params + "\n" + constructor_body[:-1]
def generate_setters(self, schema, class_name, indentation):
setters = []
schema_properties = self._get_schema_properties(schema)
if "update" in schema_properties:
update_schema = schema_properties["update"]
else:
update_schema = schema
indent = " " * indentation
for prop_name, prop in self._get_schema_properties(
update_schema).items():
if prop_name == "id":
continue
update_prop_type_hints = {
p: type_hint
for p, type_hint in self._get_update_properties(prop)
}
if "set" in update_prop_type_hints:
setter = indent + "@property\n"
setter += indent + "def {}(self):\n".format(
utils.to_snake_case(prop_name))
if update_prop_type_hints["set"] == "List":
setter += indent + indent + "return _List{}(self, '{}')".format(
class_name, prop_name)
elif update_prop_type_hints["set"] == "Dict[str, Any]":
setter += indent + indent + "return _Object{}(self, '{}')".format(
class_name, prop_name)
else:
setter += indent + indent + "return _Primitive{}(self, '{}')".format(
class_name, prop_name)
setters.append(setter)
return "\n\n".join(setters)
def generate_loader(self, schemas, class_name, indentation):
prop_to_type = dict()
ignore = [p for p in TO_EXCLUDE]
for schema in schemas:
for prop_name, prop in self._get_schema_properties(schema).items():
prop_name = utils.to_snake_case(prop_name)
if prop_name not in ignore:
type_name, special_type = self._get_type_hint_with_marker(
prop)
if special_type:
prop_to_type[prop_name] = type_name
ignore.append(prop_name)
loader = ""
if len(prop_to_type) > 0:
loader = "\n" + " " * indentation + "@classmethod\n"
loader += " " * indentation + "def _load(cls, resource: Union[Dict, str], cognite_client=None):\n"
loader += " " * (
indentation + 4
) + "instance = super({}, cls)._load(resource, cognite_client)\n".format(
class_name)
loader += " " * (indentation +
4) + "if isinstance(resource, Dict):\n"
for k, v in prop_to_type.items():
loader += " " * (indentation +
8) + "if instance.{} is not None:\n".format(k)
loader += " " * (
indentation +
12) + "instance.{} = {}(**instance.{})\n".format(k, v, k)
loader += " " * (indentation + 4) + "return instance\n"
return loader
def generate_properties(self, schemas, indentation):
properties = ""
ignore = [p for p in TO_EXCLUDE]
for schema in schemas:
for schema_name, prop in self._get_schema_properties(schema).items():
prop_name = utils.to_snake_case(schema_name)
if prop_name not in ignore:
properties += " " * indentation + '{} = CognitePropertyClassUtil.declare_property("{}")\n'.format(
prop_name, schema_name
)
ignore.append(prop_name)
return properties
def generate_docstring(self, schemas, indentation, is_property=False):
docstring = " " * indentation + '"""{}\n\n'.format(self._get_schema_description(schemas[0]))
docstring += " " * indentation + "Args:\n"
ignore = [p for p in TO_EXCLUDE]
for schema in schemas:
for prop_name, prop in self._get_schema_properties(schema).items():
if prop_name not in ignore:
docstring += " " * (indentation + 4) + "{} ({}): {}\n".format(
utils.to_snake_case(prop_name), self._get_type_hint(prop), self._get_schema_description(prop)
)
ignore.append(prop_name)
if not is_property:
docstring += (
" " * (indentation + 4) + "cognite_client (CogniteClient): The client to associate with this object.\n"
)
docstring += " " * indentation + '"""'
return docstring
