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