def type_imports(self) -> List[Import]:
column_type = self.column_type
if isinstance(column_type, str):
return [
Import(type_=Import.Type.LIBRARY,
import_name=column_type,
import_from="sqlalchemy")
]
elif isinstance(column_type, Enum):
if in_same_package(self, column_type):
return [
Import(
type_=Import.Type.LOCAL,
import_name=self.message_field.type_obj.namespace.
other[0].name,
import_from=render_path(
self.message_field.namespace.packages),
),
Import(type_=Import.Type.LIBRARY,
import_name="Enum",
import_from="sqlalchemy"),
]
else:
return [
Import(type_=Import.Type.LOCAL,
import_name=render_path(
self.message_field.type_obj.namespace.
packages)),
Import(type_=Import.Type.LIBRARY,
import_name="Enum",
import_from="sqlalchemy"),
]
elif isinstance(column_type, Message):
if not self.is_relationship:
return []
imports = [
Import(type_=Import.Type.LIBRARY,
import_name="relationship",
import_from="sqlalchemy.orm")
]
if in_same_package(self, column_type):
return imports
else:
imports.append(
Import(type_=Import.Type.LOCAL,
import_name=render_path(
column_type.namespace.packages)))
return imports
else:
return [
Import(type_=Import.Type.LOCAL,
import_name=render_path(
column_type.namespace.packages))
]
def output_interface_string(self) -> str:
interface = self.output_obj.interface # type: TypescriptMessageInterface
if in_same_package(self, interface):
return interface.root_class_name
else:
return render_path(interface.namespace +
[interface.root_class_name])
def data_root_class_name(self) -> str:
if self.namespace.other:
return "{}__{}".format(
render_path(self.namespace.other, delimiter="__"),
self.data_class_name)
else:
return self.data_class_name
def type_string(self) -> str:
column_type = self.column_type
if isinstance(column_type, str):
return "{}()".format(column_type)
elif isinstance(column_type, Enum):
if in_same_package(self, column_type):
return "Enum({})".format(
render_path(column_type.full_namespace.other))
else:
return "Enum({})".format(
render_path(column_type.full_namespace))
elif isinstance(column_type, Py3Model):
return "" # TODO: fixme
else:
raise ValueError(
"Unknown field `column_type`: {}".format(column_type))
def _source_type_string(self) -> str:
if self.type in (self.Type.MESSAGE, self.type.ENUM):
if in_same_package(self, self.type_obj):
return self.type_obj.name
else:
return render_path(self.type_obj.full_namespace)
else:
return FIELDS_TYPES_MAP[self.type]
def add_services_imports(self, imports: Imports, package: Package):
for message in self.get_services_messages(package=package):
while not isinstance(
message.parent,
Package): # for getting base message in package
message = message.parent
if in_package(message, package, exclude_root=True):
imports.add_import(
Import(type_=Import.Type.LOCAL,
import_name=message.name,
import_from=render_path(
message.namespace.packages)))
else:
imports.add_import(
Import(type_=Import.Type.LOCAL,
import_name=render_path(
message.namespace.packages)))
def relationships_strings(self) -> List[str]:
relationships = []
for field in self.fields.values(): # type: Py3Model.Field
column_type = field.column_type
if isinstance(column_type, Py3Model) and column_type.is_model:
if in_same_package(self, column_type):
relationships.append("{} = relationship('{}')".format(
field.name,
render_path(column_type.namespace.other +
[column_type.class_name])))
else:
relationships.append("{} = relationship('{}')".format(
field.name,
render_path(column_type.namespace +
[column_type.class_name])))
# else:
# raise ValueError("Relationship must be only with other model")
return relationships
def interface_name(self, package: Package = None):
pascal_case_name = to_pascal_case(self.name)
if package is None:
return "I{}".format(pascal_case_name)
else:
full_path = get_path(node=self,
namespace=package.namespace,
file_name="interfaces")
return render_path(full_path[:-1] +
["I{}".format(pascal_case_name)])
def add_proxy(self, package: Package, files: Dict[str, str]):
imports = copy(self.empty_imports)
imports.add_import(
Import(type_=Import.Type.CORE, import_name="logging"))
imports.add_import(
Import(type_=Import.Type.CORE,
import_name="List",
import_from="typing"))
imports.add_import(
Import(type_=Import.Type.LIBRARY, import_name="flask"))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="request",
import_from="flask",
import_as="flask_request"))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="BaseProxy",
import_from="horadric_lib.proxy.proxy"))
imports.add_import(
Import(
type_=Import.Type.LIBRARY,
import_name="signature_types",
import_from="horadric_lib.proxy.decorator.signature_types",
))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="BaseProxyMiddleware",
import_from="horadric_lib.proxy.middleware.base"))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="apply_middlewares",
import_from="horadric_lib.proxy.middleware.base"))
for service in package.services.values(): # type: Py3Proxy
imports.add_import(
Import(
type_=Import.Type.LOCAL,
import_name=service.client.class_name,
import_from=render_path(service.client.namespace),
))
self.add_services_imports(imports=imports,
package=service.client.parent)
context = {
"imports": imports,
"services": package.services,
"package": package
}
files[self.render_path(package=package)] = self.render(
"proxy.py.jinja2", context=context)
def add_flask_app(self, root: Root, files: Dict[str, str]):
imports = copy(self.empty_imports)
imports.add_import(
Import(type_=Import.Type.LIBRARY, import_name="grpc"))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="ProxyApplication",
import_from="horadric_lib.proxy.application"))
imports.add_import(
Import(type_=Import.Type.LIBRARY,
import_name="CORS",
import_from="flask_cors"))
imports.add_import(
Import(
type_=Import.Type.LIBRARY,
import_name="ProtocolConverterMiddleware",
import_from="horadric_lib.proxy.middleware.type_converter",
))
services = {}
for package in walk_packages(package=root):
if package.services:
for service in package.services.values():
services[service.full_name] = service
imports.add_import(
Import(type_=Import.Type.LOCAL,
import_name=render_path(service.namespace)))
imports.add_import(
Import(type_=Import.Type.LOCAL,
import_name=render_path(
service.client.namespace)))
context = {"imports": imports, "services": services, "cors": self.cors}
files["{}/flask_app.py".format(root.name)] = self.render(
"flask_app.py.jinja2", context=context)
def output_string(self) -> str:
if in_same_package(self, self.input_obj, exclude_root=True):
return render_path(self.output_obj.full_namespace.other)
else:
return render_path(self.output_obj.full_namespace)
def _get_enum_type_name(self) -> str:
return render_path(self.type_obj.full_namespace)
def root_class_name(self) -> str:
return render_path(self.namespace.other + [self.class_name],
delimiter="__")
def grpc_path_string(self) -> str:
return render_path(self.namespace[1:-1] + [self])
def output_type_string(self) -> str:
obj = self.output_obj
if in_same_package(self, obj):
return render_path(obj.namespace.other + [obj.name])
else:
return render_path(obj.namespace + [obj.name])
def no_root_name(self) -> str:
return render_path(self.namespace[1:-1] + [self.name])
def get_from_current_class_name(self, current: TypescriptMessage):
if in_same_package(self, current):
return current.root_class_name
else:
return "{}.{}".format(render_path(self.namespace.packages),
self.root_class_name)
def root_class_name(self) -> str:
return render_path(self.full_namespace.other, delimiter="__")
def _get_enum_type_name(self):
if in_same_package(self, self.type_obj):
return self.type_obj.root_class_name
else:
return render_path(self.type_obj.namespace +
[self.type_obj.root_class_name])
def no_package_type_string(self) -> str:
return render_path(self.full_namespace.other)
def full_class_name(self):
return render_path(self.namespace + [self.class_name])