211 lines
6.4 KiB
Python
211 lines
6.4 KiB
Python
"""
|
|
The script creates a new View package
|
|
=====================================
|
|
|
|
The script creates a new View package in an existing project with an MVC
|
|
template created using the create_project utility.
|
|
|
|
.. versionadded:: 1.0.0
|
|
|
|
.. seealso::
|
|
|
|
`Utility create_project <https://kivymd.readthedocs.io/en/latest/api/kivymd/tools/patterns/create_project/>`_
|
|
|
|
.. rubric:: Use a clean architecture for your applications.
|
|
|
|
To add a new view to an existing project that was created using the
|
|
`create_project` utility, use the following command::
|
|
|
|
kivymd.add_view \\
|
|
name_pattern \\
|
|
path_to_project \\
|
|
name_view
|
|
|
|
Example command::
|
|
|
|
kivymd.add_view \\
|
|
MVC \\
|
|
/Users/macbookair/Projects \\
|
|
NewScreen
|
|
|
|
You can also add new views with responsive behavior to an existing project::
|
|
|
|
kivymd.add_view \\
|
|
MVC \\
|
|
/Users/macbookair/Projects \\
|
|
NewScreen \\
|
|
--use_responsive yes
|
|
|
|
For more information about adaptive design,
|
|
`see here <https://kivymd.readthedocs.io/en/latest/components/responsivelayout/>`_.
|
|
"""
|
|
|
|
__all__ = [
|
|
"main",
|
|
]
|
|
|
|
import os
|
|
import re
|
|
|
|
from kivy import Logger
|
|
|
|
from kivymd.tools.argument_parser import ArgumentParserWithHelp
|
|
from kivymd.tools.patterns.create_project import (
|
|
chek_camel_case_name_project,
|
|
create_common_responsive_module,
|
|
create_controller,
|
|
create_model,
|
|
create_view,
|
|
)
|
|
|
|
screens_data = """%s
|
|
|
|
screens = {%s
|
|
}"""
|
|
|
|
screns_comment = """# The screen's dictionary contains the objects of the models and controllers
|
|
# of the screens of the application.
|
|
"""
|
|
|
|
|
|
def main():
|
|
"""The function of adding a new view to the project."""
|
|
|
|
global screens_data
|
|
|
|
parser = create_argument_parser()
|
|
args = parser.parse_args()
|
|
|
|
# pattern_name isn't used currently, will be used if new patterns is added in future
|
|
pattern_name = args.pattern # noqa F841
|
|
path_to_project = args.directory
|
|
name_view = args.name
|
|
use_responsive = args.use_responsive
|
|
|
|
if not os.path.exists(path_to_project):
|
|
parser.error(f"Project <{path_to_project}> does not exist...")
|
|
|
|
if name_view[-6:] != "Screen":
|
|
parser.error(
|
|
f"The name of the <{name_view}> screen should contain the word "
|
|
f"'Screen' at the end.\n"
|
|
"For example - '--name_screen MyFirstScreen ...'"
|
|
)
|
|
|
|
if name_view in os.listdir(os.path.join(path_to_project, "View")):
|
|
parser.error(
|
|
f"The <{name_view}> view also exists in the <{path_to_project}> project..."
|
|
)
|
|
|
|
# Create model.
|
|
name_database = (
|
|
"yes"
|
|
if "database.py" in os.listdir(os.path.join(path_to_project, "Model"))
|
|
else "no"
|
|
)
|
|
module_name = chek_camel_case_name_project(name_view)
|
|
if not module_name:
|
|
parser.error(
|
|
"The name of the screen should be written in camel case style. "
|
|
"\nFor example - 'MyFirstScreen'"
|
|
)
|
|
module_name = "_".join([name.lower() for name in module_name])
|
|
path_to_project = path_to_project
|
|
create_model(name_view, module_name, name_database, path_to_project)
|
|
|
|
# Create controller.
|
|
# FIXME: This is not a very good solution in order to understand whether
|
|
# a project uses a hot reload or not. Because the string
|
|
# 'from kivymd.tools.hotreload.app import MDApp' in the project can just
|
|
# be commented out and the project does not actually use hot reload.
|
|
with open(os.path.join(path_to_project, "main.py")) as main_module:
|
|
if "from kivymd.tools.hotreload.app import MDApp" in main_module.read():
|
|
use_hotreload = "yes"
|
|
else:
|
|
use_hotreload = "no"
|
|
create_controller(
|
|
name_view, module_name, use_hotreload, path_to_project
|
|
)
|
|
# Create View.
|
|
if use_responsive == "no":
|
|
create_view(name_view, module_name, [], path_to_project)
|
|
else:
|
|
create_view(name_view, module_name, [name_view], path_to_project)
|
|
create_common_responsive_module([name_view], path_to_project)
|
|
# Create 'View.screens.py module'.
|
|
create_screens_data(name_view, module_name, path_to_project)
|
|
Logger.info(
|
|
f"KivyMD: The {name_view} view has been added to the project..."
|
|
)
|
|
|
|
|
|
def create_screens_data(
|
|
name_view: str, module_name: str, path_to_project: str
|
|
) -> None:
|
|
with open(
|
|
os.path.join(path_to_project, "View", "screens.py")
|
|
) as screen_module:
|
|
screen_module = screen_module.read()
|
|
imports = re.findall(
|
|
"from Model.*Model|from Controller.*Controller", screen_module
|
|
)
|
|
screens = ""
|
|
path_to_view = os.path.join(path_to_project, "View")
|
|
|
|
for name in os.listdir(path_to_view):
|
|
if os.path.isdir(os.path.join(path_to_view, name)):
|
|
res = re.findall("[A-Z][a-z]*", name)
|
|
if res and len(res) == 2 and res[-1] == "Screen":
|
|
screens += (
|
|
"\n '%s': {"
|
|
"\n 'model': %s,"
|
|
"\n 'controller': %s,"
|
|
"\n },"
|
|
% (
|
|
f"{res[0].lower()} {res[1].lower()}",
|
|
f'{"".join(res)}Model',
|
|
f'{"".join(res)}Controller',
|
|
)
|
|
)
|
|
|
|
imports.append(f"from Model.{module_name} import {name_view}Model")
|
|
imports.append(
|
|
f"from Controller.{module_name} import {name_view}Controller"
|
|
)
|
|
imports.insert(0, screns_comment)
|
|
screens = screens_data % ("\n".join(imports), screens)
|
|
|
|
with open(
|
|
os.path.join(path_to_project, "View", "screens.py"), "w"
|
|
) as screen_module:
|
|
screen_module.write(screens)
|
|
|
|
|
|
def create_argument_parser() -> ArgumentParserWithHelp:
|
|
parser = ArgumentParserWithHelp(
|
|
prog="create_project.py",
|
|
allow_abbrev=False,
|
|
)
|
|
parser.add_argument(
|
|
"pattern",
|
|
help="the name of the pattern with which the project will be created.",
|
|
)
|
|
parser.add_argument(
|
|
"directory",
|
|
help="the directory of the project to which you want to add a new view.",
|
|
)
|
|
parser.add_argument(
|
|
"name",
|
|
help="the name of the view to add to an existing project.",
|
|
)
|
|
parser.add_argument(
|
|
"--use_responsive",
|
|
default="no",
|
|
help="whether to create a view with responsive behavior.",
|
|
)
|
|
return parser
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|