Mirrors
/
Sideband
mirror of https://github.com/markqvist/Sideband.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Sideband/sbapp/kivymd/tools/patterns/create_project.py

1238 lines
38 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
Script creates a project with the MVC pattern
=============================================
.. versionadded:: 1.0.0
.. seealso::
`MVC pattern <https://en.wikipedia.org/wiki/Model–view–controller>`_
.. rubric:: Use a clean architecture for your applications.
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/preview-mvc.png
:align: center
Use a clean architecture for your applications. KivyMD allows you to quickly
create a project template with the MVC pattern. So far, this is the only
pattern that this utility offers. You can also include database support in
your project. At the moment, support for the Firebase database
(the basic implementation of the real time database) and RestDB
(the full implementation) is available.
Project creation
----------------
Template command::
kivymd.create_project \\
name_pattern \\
path_to_project \\
name_project \\
python_version \\
kivy_version
Example command::
kivymd.create_project \\
MVC \\
/Users/macbookair/Projects \\
MyMVCProject \\
python3.10 \\
2.1.0
This command will by default create a project with an MVC pattern.
Also, the project will create a virtual environment with Python 3.10,
Kivy version 2.1.0 and KivyMD master version.
.. note::
Please note that the Python version you specified must be installed on your
computer.
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/mvc-base.png
:align: center
Creating a project using a database
-----------------------------------
.. note::
Note that in the following command, you can use one of two database names:
'firebase' or 'restdb'.
Template command::
kivymd.create_project \\
name_pattern \\
path_to_project \\
name_project \\
python_version \\
kivy_version \\
--name_database
Example command::
kivymd.create_project \\
MVC \\
/Users/macbookair/Projects \\
MyMVCProject \\
python3.10 \\
2.1.0 \\
--name_database restdb
This command will create a project with an MVC template by default.
The project will also create a virtual environment with Python 3.10,
Kivy version 2.1.0, KivyMD master version and a wrapper for working with
the database restdb.io.
.. image:: https://github.com/HeaTTheatR/KivyMD-data/raw/master/gallery/kivymddoc/mvc-database.png
:align: center
.. code-block:: python
class DataBase:
def __init__(self):
database_url = "https://restdbio-5498.restdb.io"
api_key = "7ce258d66f919d3a891d1166558765f0b4dbd"
.. note::
Please note that `database.py` the shell in the `DataBase` class uses the
`database_url` and `api_key` parameters on the test database (works only in read mode),
so you should use your data for the database.
Create project with hot reload
------------------------------
Template command::
kivymd.create_project \\
name_pattern \\
path_to_project \\
name_project \\
python_version \\
kivy_version \\
--use_hotreload
Example command::
kivymd.create_project \\
MVC \\
/Users/macbookair/Projects \\
MyMVCProject \\
python3.10 \\
2.1.0 \\
--use_hotreload yes
After creating the project, open the file `main.py`, there is a lot of useful
information. Also, the necessary information is in other modules of the project
in the form of comments. So do not forget to look at the source files of the
created project.
Create project with responsive view
-----------------------------------
When creating a project, you can specify which views should use responsive
behavior. To do this, specify the name of the view/views in the
`--use_responsive` argument:
Template command::
kivymd.create_project \\
name_pattern \\
path_to_project \\
name_project \\
python_version \\
kivy_version \\
--name_screen FirstScreen SecondScreen ThirdScreen \\
--use_responsive FirstScreen SecondScreen
The `FirstScreen` and `SecondScreen` views will be created with an responsive
architecture. For more detailed information about using the adaptive view, see
the `MDResponsiveLayout <https://kivymd.readthedocs.io/en/latest/components/responsivelayout/>`_
widget.
Others command line arguments
=============================
Required Arguments
------------------
- pattern
- the name of the pattern with which the project will be created
- directory
- directory in which the project will be created
- name
- project name
- python_version
- the version of Python (specify as `python3.9` or `python3.8`) with
- which the virtual environment will be created
- kivy_version
- version of Kivy (specify as `2.1.0` or `master`) that will be used in the project
Optional arguments
------------------
- name_screen
- the name of the class which be used when creating the project pattern
When you need to create an application template with multiple screens,
use multiple values separated by a space for the `name_screen` parameter,
for example, as shown below:
Template command::
kivymd.create_project \\
name_pattern \\
path_to_project \\
name_project \\
python_version \\
kivy_version \\
--name_screen FirstScreen SecondScreen ThirdScreen
- name_database
- provides a basic template for working with the 'firebase' library
- or a complete implementation for working with a database 'restdb.io'
- use_hotreload
- creates a hot reload entry point to the application
- use_localization
- creates application localization files
- use_responsive
- the name/names of the views to be used by the responsive UI
.. warning:: On Windows, hot reloading of Python files may not work.
But, for example, there is no such problem in macOS. If you fix this,
please report it to the KivyMD community.
"""
__all__ = [
"main",
]
import os
import re
import shutil
from typing import Union
from kivy import Logger, platform
from kivymd import path as kivymd_path
from kivymd.tools.argument_parser import ArgumentParserWithHelp
temp_basemodel = '''# The model implements the observer pattern. This means that the class must
# support adding, removing, and alerting observers. In this case, the model is
# completely independent of controllers and views. It is important that all
# registered observers implement a specific method that will be called by the
# model when they are notified (in this case, it is the `model_is_changed`
# method). For this, observers must be descendants of an abstract class,
# inheriting which, the `model_is_changed` method must be overridden.
class BaseScreenModel:
"""Implements a base class for model modules."""
_observers = []
def add_observer(self, observer) -> None:
self._observers.append(observer)
def remove_observer(self, observer) -> None:
self._observers.remove(observer)
def notify_observers(self, name_screen: str) -> None:
"""
Method that will be called by the observer when the model data changes.
:param name_screen:
name of the view for which the method should be called
:meth:`model_is_changed`.
"""
for observer in self._observers:
if observer.name == name_screen:
observer.model_is_changed()
break
'''
temp_database_model = '''import multitasking
from Model.base_model import BaseScreenModel
multitasking.set_max_threads(10)
class {name_screen}Model(BaseScreenModel):
"""
Implements the logic of the
:class:`~View.{name_screen}.{module_name}.{name_screen}View` class.
"""
def __init__(self, database):
# Just an example of the data. Use your own values.
self._data = None
@property
def data(self):
return self._data
@data.setter
def data(self, value):
self._data = value
# We notify the View -
# :class:`~View.{name_screen}.{module_name}.{name_screen}View` about the
# changes that have occurred in the data model.
self.notify_observers({notify_name_screen})
@multitasking.task
def check_data(self):
"""Just an example of the method. Use your own code."""
self.data = ["example item"]
'''
temp_without_database_model = '''from Model.base_model import BaseScreenModel
class {name_screen}Model(BaseScreenModel):
"""
Implements the logic of the
:class:`~View.{module_name}.{name_screen}.{name_screen}View` class.
"""'''
temp_screens_imports = """# The screens dictionary contains the objects of the models and controllers
# of the screens of the application.
"""
temp_code_responsive_view = '''from kivymd.uix.responsivelayout import MDResponsiveLayout
from View.{name_screen}.components import (
MobileScreenView,
TabletScreenView,
DesktopScreenView,
)
from View.base_screen import BaseScreenView
class {name_screen}View(MDResponsiveLayout, BaseScreenView):
def __init__(self, **kw):
super().__init__(**kw)
self.mobile_view = MobileScreenView()
self.tablet_view = TabletScreenView()
self.desktop_view = DesktopScreenView()
def model_is_changed(self) -> None:
"""
Called whenever any change has occurred in the data model.
The view in this method tracks these changes and updates the UI
according to these changes.
"""
'''
temp_responsive_component_imports = """from .platforms.MobileScreen.mobile_screen import MobileScreenView
from .platforms.TabletScreen.tablet_screen import TabletScreenView
from .platforms.DesktopScreen.desktop_screen import DesktopScreenView
"""
temp_responsive_platform_baseclass = """from kivymd.uix.screen import MDScreen
class {}View(MDScreen):
pass
"""
temp_code_view = '''from View.base_screen import BaseScreenView
class {name_screen}View(BaseScreenView):
def model_is_changed(self) -> None:
"""
Called whenever any change has occurred in the data model.
The view in this method tracks these changes and updates the UI
according to these changes.
"""
'''
temp_code_controller = '''{import_module}
class {name_screen}Controller:
"""
The `{name_screen}Controller` class represents a controller implementation.
Coordinates work of the view with the model.
The controller implements the strategy pattern. The controller connects to
the view to control its actions.
"""
def __init__(self, model):
self.model = model # Model.{module_name}.{name_screen}Model
self.view = {name_view}(controller=self, model=self.model)
def get_view(self) -> {get_view}:
return self.view
'''
temp_base_screen = '''from kivy.properties import ObjectProperty
from kivymd.app import MDApp
from kivymd.theming import ThemableBehavior
from kivymd.uix.screen import MDScreen
from Utility.observer import Observer
class BaseScreenView(ThemableBehavior, MDScreen, Observer):
"""
A base class that implements a visual representation of the model data.
The view class must be inherited from this class.
"""
controller = ObjectProperty()
"""
Controller object - :class:`~Controller.controller_screen.ClassScreenControler`.
:attr:`controller` is an :class:`~kivy.properties.ObjectProperty`
and defaults to `None`.
"""
model = ObjectProperty()
"""
Model object - :class:`~Model.model_screen.ClassScreenModel`.
:attr:`model` is an :class:`~kivy.properties.ObjectProperty`
and defaults to `None`.
"""
manager_screens = ObjectProperty()
"""
Screen manager object - :class:`~kivymd.uix.screenmanager.MDScreenManager`.
:attr:`manager_screens` is an :class:`~kivy.properties.ObjectProperty`
and defaults to `None`.
"""
def __init__(self, **kw):
super().__init__(**kw)
# Often you need to get access to the application object from the view
# class. You can do this using this attribute.
self.app = MDApp.get_running_app()
# Adding a view class as observer.
self.model.add_observer(self)
'''
temp_utility = '''
# Of course, "very flexible Python" allows you to do without an abstract
# superclass at all or use the clever exception `NotImplementedError`. In my
# opinion, this can negatively affect the architecture of the application.
# I would like to point out that using Kivy, one could use the on-signaling
# model. In this case, when the state changes, the model will send a signal
# that can be received by all attached observers. This approach seems less
# universal - you may want to use a different library in the future.
class Observer:
"""Abstract superclass for all observers."""
def model_is_changed(self):
"""
The method that will be called on the observer when the model changes.
"""
'''
temp_hot_reload_main = '''
"""
Script for managing hot reloading of the project.
For more details see the documentation page -
https://kivymd.readthedocs.io/en/latest/api/kivymd/tools/patterns/create_project/
To run the application in hot boot mode, execute the command in the console:
DEBUG=1 python main.py
"""
import importlib
import os
from kivy import Config
from PIL import ImageGrab
# TODO: You may know an easier way to get the size of a computer display.
resolution = ImageGrab.grab().size
# Change the values of the application window size as you need.
Config.set("graphics", "height", resolution[1])
Config.set("graphics", "width", "400")
from kivy.core.window import Window{}
# Place the application window on the right side of the computer screen.
Window.top = 0
Window.left = resolution[0] - Window.width
from kivymd.tools.hotreload.app import MDApp
from kivymd.uix.screenmanager import MDScreenManager
{}{}
class {}(MDApp):
KV_DIRS = [os.path.join(os.getcwd(), "View")]{}
def build_app(self) -> MDScreenManager:
"""
In this method, you don't need to change anything other than the
application theme.
"""
import View.screens
self.manager_screens = MDScreenManager(){}{}
Window.bind(on_key_down=self.on_keyboard_down)
importlib.reload(View.screens)
screens = View.screens.screens
for i, name_screen in enumerate(screens.keys()):
model = screens[name_screen]["model"]({})
controller = screens[name_screen]["controller"](model)
view = controller.get_view()
view.manager_screens = self.manager_screens
view.name = name_screen
self.manager_screens.add_widget(view)
return self.manager_screens
def on_keyboard_down(self, window, keyboard, keycode, text, modifiers) -> None:
"""
The method handles keyboard events.
By default, a forced restart of an application is tied to the
`CTRL+R` key on Windows OS and `COMMAND+R` on Mac OS.
"""
if "meta" in modifiers or "ctrl" in modifiers and text == "r":
self.rebuild(){}{}
{}().run()
# After you finish the project, remove the above code and uncomment the below
# code to test the application normally without hot reloading.
'''
temp_main = '''"""
The entry point to the application.
The application uses the MVC template. Adhering to the principles of clean
architecture means ensuring that your application is easy to test, maintain,
and modernize.
You can read more about this template at the links below:
https://github.com/HeaTTheatR/LoginAppMVC
https://en.wikipedia.org/wiki/Model–view–controller
"""
{}
from kivymd.app import MDApp
from kivymd.uix.screenmanager import MDScreenManager
from View.screens import screens{}
{}
class {}(MDApp):{}
def __init__(self, **kwargs):
super().__init__(**kwargs){}
self.load_all_kv_files(self.directory)
# This is the screen manager that will contain all the screens of your
# application.
self.manager_screens = MDScreenManager()
{}
def build(self) -> MDScreenManager:
self.generate_application_screens()
return self.manager_screens
def generate_application_screens(self) -> None:
"""
Creating and adding screens to the screen manager.
You should not change this cycle unnecessarily. He is self-sufficient.
If you need to add any screen, open the `View.screens.py` module and
see how new screens are added according to the given application
architecture.
"""
for i, name_screen in enumerate(screens.keys()):
model = screens[name_screen]["model"]({})
controller = screens[name_screen]["controller"](model)
view = controller.get_view()
view.manager_screens = self.manager_screens
view.name = name_screen
self.manager_screens.add_widget(view)
{}{}
{}().run()
'''
temp_makefile = """# FILE TO FIND AND CREATE LOCALIZATION FILES FOR YOUR APPLICATION. \\
\\
In this file, you can specify in which files of your project to search for \\
localization strings. \\
These files should be listed in the below command: \\
\\
\\
xgettext -Lpython --output=messages.pot --from-code=utf-8 \\
path/to/file-1 \\
path/to/file-2 \\
...
.PHONY: po mo
po:
xgettext -Lpython --output=messages.pot --from-code=utf-8 \\
{}
msgmerge --update --no-fuzzy-matching --backup=off data/locales/po/en.po messages.pot
msgmerge --update --no-fuzzy-matching --backup=off data/locales/po/ru.po messages.pot
mo:
mkdir -p data/locales/en/LC_MESSAGES
mkdir -p data/locales/ru/LC_MESSAGES
msgfmt -c -o data/locales/en/LC_MESSAGES/%s.mo data/locales/po/en.po
msgfmt -c -o data/locales/ru/LC_MESSAGES/%s.mo data/locales/po/ru.po
"""
firebase_requirements = """kivy==2.1.0
kivymd==1.0.0
multitasking
firebase
firebase-admin
python_jwt
gcloud
sseclient
pycryptodome==3.4.3
requests_toolbelt
"""
without_firebase_requirements = """kivy==2.1.0
kivymd==1.0.0
"""
available_patterns = ["MVC"]
available_databases = ["firebase", "restdb"]
path_to_project = ""
project_name = ""
use_localization = ""
name_database = ""
use_hotreload = ""
temp_makefile_files = ""
temp_screens_data = ""
kivy_version = ""
python_version = ""
def main():
"""Project creation function."""
global project_name
global use_localization
global name_database
global use_hotreload
global temp_makefile_files
global temp_screens_data
global path_to_project
global kivy_version
global python_version
parser = create_argument_parser()
args = parser.parse_args()
pattern_name = args.pattern
project_directory = args.directory
project_name = "".join(args.name.split(" "))
kivy_version = args.kivy_version
python_version = args.python_version
if "3" not in python_version:
parser.error("Python must be at least version 3")
name_screen = args.name_screen
path_to_project = os.path.join(project_directory, project_name)
name_database = args.name_database
if name_database != "no" and name_database not in available_databases:
parser.error(
f"The database name must be one of the {available_databases} list"
)
use_hotreload = args.use_hotreload
use_localization = args.use_localization
use_responsive = args.use_responsive
# Check arguments.
for name in name_screen:
if name[-6:] != "Screen":
parser.error(
f"The name of the {name} screen should contain the word "
f"'Screen' at the end.\n"
"For example - '--name_screen MyFirstScreen ...'"
)
if not os.path.exists(
os.path.join(kivymd_path, "tools", "patterns", pattern_name)
):
parser.error(
f"There is no {pattern_name} pattern.\n"
f"Only {available_patterns} template is available."
)
# Call the functions of creating a project.
if not os.path.exists(path_to_project):
shutil.copytree(
os.path.join(kivymd_path, "tools", "patterns", pattern_name),
path_to_project,
)
create_main()
for name in name_screen:
module_name = chek_camel_case_name_project(name)
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])
# Create models module.
create_model(name, module_name, name_database, path_to_project)
# Create controllers module.
create_controller(name, module_name, use_hotreload, path_to_project)
# Create screens data.
create_screens_data(name, module_name)
if use_localization == "yes":
# Create makefile data.
create_makefile_data(name, module_name)
# Create views.
create_view(name, module_name, use_responsive, path_to_project)
# Create module `NameProject/View/NameScreen/components/common/__init__.py`.
create_common_responsive_module(use_responsive, path_to_project)
# Create module `NameProject/View/screens.py`.
create_module_screens()
# Create module `NameProject/Model/base_model.py`.
create_basemodel()
# Create module `NameProject/View/base_screen.py`.
create_module_basescreen()
# Create package `NameProject/Utility`.
create_package_utility()
# Create file `NameProject/Makefile`.
if use_localization == "yes":
# Create makefile data.
create_makefile()
create_requirements()
os.makedirs(os.path.join(path_to_project, "assets", "images"))
os.mkdir(os.path.join(path_to_project, "assets", "fonts"))
if name_database != "no":
check_databases()
if use_hotreload == "yes":
create_main_with_hotreload()
with open(
os.path.join(path_to_project, "requirements.txt"),
"a",
encoding="utf-8",
) as requirements:
requirements.write("watchdog")
if use_localization == "yes":
Logger.info("KivyMD: Create localization files...")
os.chdir(path_to_project)
os.system("make po")
os.system("make mo")
else:
os.remove(os.path.join(path_to_project, "messages.pot"))
os.remove(os.path.join(path_to_project, "libs", "translation.py"))
shutil.rmtree(os.path.join(path_to_project, "data"))
Logger.info(f"KivyMD: Project '{path_to_project}' created")
Logger.info(
f"KivyMD: Create a virtual environment for '{path_to_project}' project..."
)
create_virtual_environment()
Logger.info(
f"KivyMD: Install requirements for '{path_to_project}' project..."
)
install_requirements()
os.remove(os.path.join(path_to_project, "__init__.py"))
if name_database == "no":
os.remove(
os.path.join(path_to_project, "Model", "database_firebase.py")
)
os.remove(
os.path.join(path_to_project, "Model", "database_restdb.py")
)
else:
parser.error(f"The {path_to_project} project already exists")
def create_main_with_hotreload() -> None:
with open(
os.path.join(path_to_project, "main.py"), encoding="utf-8"
) as main_file:
main_code = ""
for string in main_file.readlines():
main_code += f"# {string}"
with open(
os.path.join(path_to_project, "main.py"), "w", encoding="utf-8"
) as main_file:
main_file.write(f"{temp_hot_reload_main}\n{main_code}")
with open(
os.path.join(path_to_project, "main.py"), encoding="utf-8"
) as main_file:
main_code = main_file.read()
main_code = main_code.format(
"\nfrom kivy.properties import StringProperty\n"
if use_localization == "yes"
else "",
"\nfrom Model.database import DataBase"
if name_database != "no"
else "",
"\nfrom libs.translation import Translation\n"
if use_localization == "yes"
else "",
project_name,
'\n lang = StringProperty("en")\n'
if use_localization == "yes"
else "",
"\n self.base = DataBase()\n"
if name_database != "no"
else "",
"\n self.translation = Translation(\n"
' self.lang, "%s", os.path.join(self.directory, "data", "locales")'
"\n )" % project_name
if use_localization == "yes"
else "",
"self.database" if name_database != "no" else "",
"\n\n def on_lang(self, instance_app, lang_value: str) -> None:\n"
" self.translation.switch_lang(lang_value)\n"
if use_localization == "yes"
else "",
"\n def switch_lang(self) -> None:\n"
' """Switch lang."""\n\n'
' self.lang = "ru" if self.lang == "en" else "en"'
if use_localization == "yes"
else "",
project_name,
)
with open(
os.path.join(path_to_project, "main.py"), "w", encoding="utf-8"
) as main_module:
main_module.write(main_code)
def create_main() -> None:
main_code = temp_main.format(
"\nfrom kivy.properties import StringProperty\n"
if use_localization == "yes"
else "",
"\nfrom libs.translation import Translation"
if use_localization == "yes"
else "",
"from Model.database import DataBase\n"
if name_database != "no"
else "",
project_name,
'\n lang = StringProperty("en")\n'
if use_localization == "yes"
else "",
"\n self.translation = Translation(\n"
' self.lang, "%s", os.path.join(self.directory, "data", "locales")'
"\n )" % project_name
if use_localization == "yes"
else "",
"self.database = DataBase()\n" if name_database != "no" else "",
"self.database" if name_database != "no" else "",
"\n def on_lang(self, instance_app, lang_value: str) -> None:\n"
" self.translation.switch_lang(lang_value)\n"
if use_localization == "yes"
else "",
"\n def switch_lang(self) -> None:\n"
' """Switch lang."""\n\n'
' self.lang = "ru" if self.lang == "en" else "en"\n'
if use_localization == "yes"
else "",
project_name,
)
with open(
os.path.join(path_to_project, "main.py"), "w", encoding="utf-8"
) as main_module:
main_module.write(main_code)
def create_model(
name_screen: str, module_name: str, name_database: str, path_to_project: str
) -> None:
if name_database != "no":
code_model = temp_database_model.format(
name_screen=name_screen,
module_name=module_name,
notify_name_screen=f'"{" ".join(module_name.split("_"))}"',
)
else:
code_model = temp_without_database_model.format(
module_name=module_name, name_screen=name_screen
)
model_module = os.path.join(path_to_project, "Model", module_name)
with open(f"{model_module}.py", "w", encoding="utf-8") as module:
module.write(code_model)
def create_basemodel() -> None:
with open(
os.path.join(path_to_project, "Model", "base_model.py"),
"w",
encoding="utf-8",
) as module_basemodel:
module_basemodel.write(temp_basemodel)
def create_module_basescreen() -> None:
with open(
os.path.join(path_to_project, "View", "base_screen.py"),
"w",
encoding="utf-8",
) as base_screen:
base_screen.write(temp_base_screen)
def create_controller(
name_screen: str, module_name: str, use_hotreload: str, path_to_project: str
) -> None:
name_view = (
f"View.{name_screen}.{module_name}.{name_screen}View"
if use_hotreload == "yes"
else f"{name_screen}View"
)
code_controller = temp_code_controller.format(
name_screen=name_screen,
module_name=module_name,
import_module=""
f"import importlib\n\n"
f"import View.{name_screen}.{module_name}\n\n"
f"# We have to manually reload the view module in order to apply the\n"
f"# changes made to the code on a subsequent hot reload.\n"
f"# If you no longer need a hot reload, you can delete this instruction.\n"
f"importlib.reload(View.{name_screen}.{module_name})\n\n"
if use_hotreload == "yes"
else f"\nfrom View.{name_screen}.{module_name} import {name_screen}View",
name_view=name_view,
get_view=f"View.{name_screen}.{module_name}"
if use_hotreload == "yes"
else f"{name_screen}View",
)
path_to_controller = os.path.join(path_to_project, "Controller")
if not os.path.exists(path_to_controller):
os.mkdir(path_to_controller)
controller_module = os.path.join(path_to_project, "Controller", module_name)
with open(f"{controller_module}.py", "w", encoding="utf-8") as module:
module.write(code_controller)
def create_makefile() -> None:
makefile = temp_makefile.format(temp_makefile_files[:-2])
with open(
os.path.join(path_to_project, "Makefile"), "w", encoding="utf-8"
) as make_file:
make_file.write(makefile)
def create_makefile_data(name_screen: str, module_name: str) -> None:
global temp_makefile_files
temp_makefile_files += (
f" View/{name_screen}/{module_name}.py \\\n"
)
temp_makefile_files += (
f" View/{name_screen}/{module_name}.kv \\\n"
)
def create_screens_data(name_screen: str, module_name: str) -> None:
global temp_screens_imports
global temp_screens_data
temp_screens_imports += (
f"from Model.{module_name} import {name_screen}Model\n"
f"from Controller.{module_name} import {name_screen}Controller\n"
)
temp_screens_data += (
'\n %s: {\n "model": %s,'
'\n "controller": %s,\n },\n'
% (
f'"{" ".join(module_name.split("_"))}"',
f"{name_screen}Model",
f"{name_screen}Controller",
)
)
def create_module_screens() -> None:
path_to_module_screens = os.path.join(path_to_project, "View", "screens.py")
with open(path_to_module_screens, "w", encoding="utf-8") as module_screens:
module_screens.write(
"%s\nscreens = {%s}" % (temp_screens_imports, temp_screens_data)
)
def create_common_responsive_module(
use_responsive: list, path_to_project: str
) -> None:
for name_screen in use_responsive:
path_to_init_common = os.path.join(
path_to_project, "View", name_screen, "components", "common"
)
os.makedirs(path_to_init_common)
with open(
os.path.join(path_to_init_common, "__init__.py"),
"w",
encoding="utf-8",
) as init_common_components:
init_common_components.write(
"# This directory is for common responsive design components\n"
)
def create_view(
name_screen: str,
module_name: str,
use_responsive: list,
path_to_project: str,
) -> None:
path_to_view = os.path.join(path_to_project, "View", name_screen)
path_to_components = os.path.join(path_to_view, "components")
view_module = os.path.join(path_to_view, module_name)
os.makedirs(path_to_view)
os.makedirs(path_to_components)
with open(
os.path.join(path_to_view, "__init__.py"), "w", encoding="utf-8"
) as init_module:
init_module.write("")
with open(f"{view_module}.py", "w", encoding="utf-8") as view_file:
view_file.write(
temp_code_view.format(name_screen=name_screen)
if name_screen not in use_responsive
else temp_code_responsive_view.format(name_screen=name_screen)
)
if name_screen in use_responsive:
for name_platform in ["DesktopScreen", "MobileScreen", "TabletScreen"]:
path_to_init_components = os.path.join(
path_to_project,
"View",
name_screen,
"components",
"__init__.py",
)
path_to_platforms = os.path.join(
path_to_project, "View", name_screen, "components", "platforms"
)
path_to_platform = os.path.join(path_to_platforms, name_platform)
path_to_platform_components = os.path.join(
path_to_platform, "components"
)
os.makedirs(path_to_platform_components)
shutil.copy(
os.path.join(path_to_view, "__init__.py"),
path_to_platform_components,
)
shutil.copy(
os.path.join(path_to_view, "__init__.py"), path_to_platforms
)
name_platform_module = (
f'{name_platform.split("Screen")[0].lower()}_screen'
)
with open(
os.path.join(path_to_platform, f"{name_platform_module}.kv"),
"w",
encoding="utf-8",
) as platform_rule:
platform_rule.write(f"<{name_platform}View>\n")
with open(
os.path.join(path_to_platform, f"{name_platform_module}.py"),
"w",
encoding="utf-8",
) as platform_baseclass:
platform_baseclass.write(
temp_responsive_platform_baseclass.format(name_platform)
)
with open(
path_to_init_components, "w", encoding="utf-8"
) as init_components:
init_components.write(temp_responsive_component_imports)
with open(f"{view_module}.kv", "w", encoding="utf-8") as view_file:
view_file.write(f"<{name_screen}View>\n")
if name_screen not in use_responsive:
shutil.copy(
os.path.join(path_to_view, "__init__.py"), path_to_components
)
def create_package_utility() -> None:
path_to_utility = os.path.join(path_to_project, "Utility")
os.mkdir(path_to_utility)
with open(
os.path.join(path_to_utility, "__init__.py"), "w", encoding="utf-8"
) as init_module:
init_module.write("")
with open(
os.path.join(path_to_utility, "observer.py"), "w", encoding="utf-8"
) as observer:
observer.write(temp_utility)
def create_requirements() -> None:
with open(
os.path.join(path_to_project, "requirements.txt"), "w", encoding="utf-8"
) as requirements:
requirements.write(
firebase_requirements
if name_database == "firebase"
else without_firebase_requirements
)
def create_virtual_environment() -> None:
os.system(f"{python_version} -m pip install virtualenv")
os.system(
f"virtualenv -p {python_version} {os.path.join(path_to_project, 'venv')}"
)
def install_requirements() -> None:
python = os.path.join(path_to_project, "venv", "bin", "python3")
if kivy_version == "master":
if platform == "macosx":
os.system(
f"{python} -m pip install 'kivy[base] @ https://github.com/kivy/kivy/archive/master.zip'"
)
else:
os.system(
f"{python} -m pip install https://github.com/kivy/kivy/archive/master.zip"
)
elif kivy_version == "stable":
os.system(f"{python} -m pip install kivy")
else:
os.system(f"{python} -m pip install kivy=={kivy_version}")
os.system(
f"{python} -m pip install https://github.com/kivymd/KivyMD/archive/master.zip"
)
os.system(f"{python} -m pip install watchdog")
if name_database == "firebase":
os.system(
f"{python} -m pip install "
f"multitasking "
f"firebase "
f"firebase-admin "
f"python_jwt "
f"gcloud "
f"sseclient "
f"pycryptodome==3.4.3 "
f"requests_toolbelt "
f"watchdog "
)
os.system(
f"{os.path.join(path_to_project, 'venv', 'bin', 'python3')} -m pip list"
)
def check_databases() -> None:
databases = {"firebase": "restdb", "restdb": "firebase"}
os.remove(
os.path.join(
path_to_project, "Model", f"database_{databases[name_database]}.py"
)
)
os.rename(
os.path.join(path_to_project, "Model", f"database_{name_database}.py"),
os.path.join(path_to_project, "Model", "database.py"),
)
def chek_camel_case_name_project(name_project) -> Union[bool, list]:
result = re.findall("[A-Z][a-z]*", name_project)
if len(result) == 1:
return False
return result
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="directory in which the project will be created.",
)
parser.add_argument(
"name",
help="project name.",
)
parser.add_argument(
"python_version",
help="the version of Python (specify as `python3.9` or `python3.8`) "
"with which the virtual environment will be created.",
)
parser.add_argument(
"kivy_version",
help="version of Kivy (specify as `2.1.0` or `master`) that will be "
"used in the project.",
)
parser.add_argument(
"--name_screen",
nargs="*",
type=str,
default=["MainScreen"],
help="the name/names of the class which be used when creating the project pattern.",
)
parser.add_argument(
"--use_responsive",
nargs="*",
type=str,
default=[],
help="the name/names of the views to be used by the responsive UI.",
)
parser.add_argument(
"--name_database",
default="no",
help="name of the database provider ('firebase' or 'restdb').",
)
parser.add_argument(
"--use_hotreload",
default="no",
help="creates a hot reload entry point to the application.",
)
parser.add_argument(
"--use_localization",
default="no",
help="creates application localization files.",
)
return parser
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink