src/cpl_cli/.cpl/project_library.py

@@ -19,13 +19,10 @@ class Library(ProjectTypeABC):
             project_file_data: dict,
     ):
         from project_file import ProjectFile
-        from project_file_appsettings import ProjectFileAppsettings
-        from project_file_code_application import ProjectFileApplication
-        from project_file_code_main import ProjectFileMain
-        from project_file_code_startup import ProjectFileStartup
         from project_file_readme import ProjectFileReadme
         from project_file_license import ProjectFileLicense
         from schematic_init import Init
+        from schematic_class import Class
 
         ProjectTypeABC.__init__(self, base_path, project_name, workspace, use_application_api, use_startup, use_service_providing, use_async, project_file_data)
 
@@ -35,15 +32,6 @@ class Library(ProjectTypeABC):
         if workspace is None:
             self.add_template(ProjectFileLicense(''))
             self.add_template(ProjectFileReadme(''))
-            self.add_template(Init('', 'init', f'{base_path}tests/'))
 
         self.add_template(Init('', 'init', project_path))
-        self.add_template(ProjectFileAppsettings(project_path))
+        self.add_template(Class('Class1', 'class', project_path))
-
-        if use_application_api:
-            self.add_template(ProjectFileApplication(project_path, use_application_api, use_startup, use_service_providing, use_async))
-
-        if use_startup:
-            self.add_template(ProjectFileStartup(project_path, use_application_api, use_startup, use_service_providing, use_async))
-
-        self.add_template(ProjectFileMain(project_name.split('/')[-1], project_path, use_application_api, use_startup, use_service_providing, use_async))

src/cpl_cli/.cpl/schematic_class.py

@@ -4,8 +4,8 @@ from cpl_core.utils import String
 
 class Class(GenerateSchematicABC):
 
-    def __init__(self, name: str, path: str, schematic: str):
+    def __init__(self, name: str, schematic: str, path: str):
-        GenerateSchematicABC.__init__(self, name, path, schematic)
+        GenerateSchematicABC.__init__(self, name, schematic, path)
         self._name = f'{String.convert_to_snake_case(name)}.py'
         self._class_name = f'{String.first_to_upper(name)}'
 

src/cpl_cli/command/generate_service.py

@@ -34,6 +34,7 @@ class GenerateService(CommandABC):
         self._config = configuration
         self._env = self._config.environment
         self._schematics = {}
+        self._schematic_classes = set()
 
         for package_name, version in Dependencies.get_cpl_packages():
             if package_name == 'cpl-cli':
@@ -44,16 +45,12 @@ class GenerateService(CommandABC):
         self._read_custom_schematics_from_path(self._env.working_directory)
         self._read_custom_schematics_from_path(self._env.runtime_directory)
 
-        if len(GenerateSchematicABC.__subclasses__()) == 0:
+        if len(self._schematic_classes) == 0:
             Console.error(f'No schematics found in template directory: .cpl')
             sys.exit()
 
         known_schematics = []
-        for schematic in GenerateSchematicABC.__subclasses__():
+        for schematic in self._schematic_classes:
-            if schematic.__name__ in known_schematics:
-                Console.error(f'Duplicate of schematic {schematic.__name__} found!')
-                sys.exit()
-
             known_schematics.append(schematic.__name__)
             schematic.register()
 
@@ -83,6 +80,23 @@ class GenerateService(CommandABC):
             help_msg += f'\n    {schematic}'
         return help_msg
 
+    def _read_custom_schematics_from_path(self, path: str):
+        if not os.path.exists(os.path.join(path, '.cpl')):
+            return
+
+        sys.path.insert(0, os.path.join(path, '.cpl'))
+        for r, d, f in os.walk(os.path.join(path, '.cpl')):
+            for file in f:
+                if not file.startswith('schematic_') or not file.endswith('.py'):
+                    continue
+
+                try:
+                    exec(open(os.path.join(r, file), 'r').read())
+                    self._schematic_classes.update(GenerateSchematicABC.__subclasses__())
+                except Exception as e:
+                    Console.error(str(e), traceback.format_exc())
+                    sys.exit(-1)
+
     @staticmethod
     def _create_file(file_path: str, value: str):
         """
@@ -157,23 +171,6 @@ class GenerateService(CommandABC):
             spinner_foreground_color=ForegroundColorEnum.cyan
         )
 
-    @staticmethod
-    def _read_custom_schematics_from_path(path: str):
-        if not os.path.exists(os.path.join(path, '.cpl')):
-            return
-
-        sys.path.insert(0, os.path.join(path, '.cpl'))
-        for r, d, f in os.walk(os.path.join(path, '.cpl')):
-            for file in f:
-                if not file.startswith('schematic_') or not file.endswith('.py'):
-                    continue
-
-                try:
-                    exec(open(os.path.join(r, file), 'r').read())
-                except Exception as e:
-                    Console.error(str(e), traceback.format_exc())
-                    sys.exit(-1)
-
     def _get_schematic_by_alias(self, schematic: str) -> str:
         for key in self._schematics:
             if schematic in self._schematics[key]['Aliases']:

src/cpl_cli/command/new_service.py

@@ -45,6 +45,8 @@ class NewService(CommandABC):
         self._build: BuildSettings = BuildSettings()
         self._build_dict = {}
 
+        self._project_type_classes = set()
+
         self._name: str = ''
         self._rel_path: str = ''
         self._project_type: ProjectTypeEnum = ProjectTypeEnum.console
@@ -98,7 +100,7 @@ class NewService(CommandABC):
             ],
             ProjectSettingsNameEnum.python_version.value: f'>={sys.version.split(" ")[0]}',
             ProjectSettingsNameEnum.python_path.value: {
-                sys.platform: '../../venv/bin/python' if self._use_venv else ''
+                sys.platform: '../../venv/' if self._use_venv else ''
             },
             ProjectSettingsNameEnum.classifiers.value: []
         }
@@ -152,17 +154,22 @@ class NewService(CommandABC):
 
         return project_path
 
-    def _get_project_information(self, is_unittest=False):
+    def _get_project_information(self, project_type: str):
         """
         Gets project information's from user
         :return:
         """
+        is_unittest = project_type == 'unittest'
+        is_library = project_type == 'library'
+        if is_library:
+            return
+
         if self._use_application_api or self._use_startup or self._use_service_providing or self._use_async or self._use_nothing:
             Console.set_foreground_color(ForegroundColorEnum.default)
             Console.write_line('Skipping question due to given flags')
             return
 
-        if not is_unittest:
+        if not is_unittest and not is_library:
             self._use_application_api = Console.read('Do you want to use application base? (y/n) ').lower() == 'y'
 
         if not is_unittest and self._use_application_api:
@@ -194,8 +201,7 @@ class NewService(CommandABC):
             explicit_path=os.path.join(self._env.working_directory, project, self._project.python_executable.replace('../', ''))
         )
 
-    @staticmethod
+    def _read_custom_project_types_from_path(self, path: str):
-    def _read_custom_project_types_from_path(path: str):
         if not os.path.exists(os.path.join(path, '.cpl')):
             return
 
@@ -207,28 +213,28 @@ class NewService(CommandABC):
 
                 try:
                     exec(open(os.path.join(r, file), 'r').read())
+                    self._project_type_classes.update(ProjectTypeABC.__subclasses__())
                 except Exception as e:
                     Console.error(str(e), traceback.format_exc())
                     sys.exit(-1)
 
     def _create_project(self, project_type: str):
         for package_name in Dependencies.get_cpl_packages():
+            if package_name == 'cpl-cli':
+                continue
             package = importlib.import_module(String.convert_to_snake_case(package_name[0]))
             self._read_custom_project_types_from_path(os.path.dirname(package.__file__))
 
         self._read_custom_project_types_from_path(self._env.working_directory)
+        self._read_custom_project_types_from_path(self._env.runtime_directory)
 
-        if len(ProjectTypeABC.__subclasses__()) == 0:
+        if len(self._project_type_classes) == 0:
             Console.error(f'No project types found in template directory: .cpl')
             sys.exit()
 
         project_class = None
         known_project_types = []
-        for p in ProjectTypeABC.__subclasses__():
+        for p in self._project_type_classes:
-            if p.__name__ in known_project_types:
-                Console.error(f'Duplicate of project type {p.__name__} found!')
-                sys.exit()
-
             known_project_types.append(p.__name__)
             if p.__name__.lower() != project_type and p.__name__.lower()[0] != project_type[0]:
                 continue
@@ -247,7 +253,7 @@ class NewService(CommandABC):
         if path is None:
             return
 
-        self._get_project_information()
+        self._get_project_information(project_type)
         project_name = self._project.name
         if self._rel_path != '':
             project_name = f'{self._rel_path}/{project_name}'

src/cpl_cli/configuration/project_settings.py

@@ -123,10 +123,16 @@ class ProjectSettings(ConfigurationModelABC):
             self._python_path = settings[ProjectSettingsNameEnum.python_path.value]
 
             if ProjectSettingsNameEnum.python_path.value in settings and sys.platform in settings[ProjectSettingsNameEnum.python_path.value]:
-                path = f'{settings[ProjectSettingsNameEnum.python_path.value][sys.platform]}/bin/python'
+                path = f'{settings[ProjectSettingsNameEnum.python_path.value][sys.platform]}'
+
                 if path == '' or path is None:
                     Error.warn(f'{ProjectSettingsNameEnum.python_path.value} not set')
                     path = sys.executable
+                else:
+                    if not path.endswith('bin/python'):
+                        if not path.endswith('/') and len(path) > 0:
+                            path += '/'
+                        path += 'bin/python'
             else:
                 path = sys.executable
 

src/cpl_cli/configuration/venv_helper_service.py

@@ -17,7 +17,7 @@ class VenvHelper:
         if is_virtual:
             return
 
-        venv_path = os.path.abspath(os.path.join(env.working_directory, project_settings.python_executable))
+        venv_path = os.path.abspath(os.path.join(env.working_directory, project_settings.python_executable, '../../'))
 
         if explicit_path is not None:
             venv_path = os.path.abspath(explicit_path)
@@ -31,7 +31,7 @@ class VenvHelper:
                 spinner_foreground_color=ForegroundColorEnum.cyan
             )
 
-        Pip.set_executable(venv_path)
+        Pip.set_executable(project_settings.python_executable)
 
     @staticmethod
     def create_venv(path):

src/cpl_cli/startup_migration_extension.py

@@ -1,18 +1,11 @@
-import os
-from typing import Optional
-
-from cpl_cli.command.custom_script_service import CustomScriptService
-from cpl_cli.configuration.workspace_settings import WorkspaceSettings
 from cpl_cli.migrations.base.migration_abc import MigrationABC
 from cpl_cli.migrations.base.migration_service_abc import MigrationServiceABC
 from cpl_cli.migrations.migration_2022_10 import Migration202210
 from cpl_cli.migrations.service.migration_service import MigrationService
 from cpl_core.application.startup_extension_abc import StartupExtensionABC
-from cpl_core.configuration.argument_type_enum import ArgumentTypeEnum
 from cpl_core.configuration.configuration_abc import ConfigurationABC
 from cpl_core.dependency_injection.service_collection_abc import ServiceCollectionABC
 from cpl_core.environment.application_environment_abc import ApplicationEnvironmentABC
-from cpl_core.utils.string import String
 
 
 class StartupMigrationExtension(StartupExtensionABC):

src/cpl_cli/test_enum.py

@@ -1 +0,0 @@
-# imports

src/cpl_cli/test_init.py

@@ -1 +0,0 @@
-# imports

src/cpl_core/cpl-core.json

@@ -53,7 +53,11 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {},
+    "PackageData": {
+      "cpl_core": [
+        ".cpl/*.py"
+      ]
+    },
     "ProjectReferences": []
   }
 }

src/cpl_core/utils/pip.py

@@ -33,7 +33,7 @@ class Pip:
             return
 
         cls._executable = executable
-        if not os.path.islink(cls._executable):
+        if not os.path.islink(cls._executable) or not os.path.isfile(executable):
             return
 
         path = os.path.dirname(os.path.dirname(cls._executable))
@@ -119,6 +119,7 @@ class Pip:
         if source is not None:
             pip_args.append(f'--extra-index-url')
             pip_args.append(source)
+
         subprocess.run(pip_args, stdout=stdout, stderr=stderr, env=cls._env)
 
     @classmethod

src/cpl_discord/cpl-discord.json

@@ -40,7 +40,11 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {},
+    "PackageData": {
+      "cpl_discord": [
+        ".cpl/*.py"
+      ]
+    },
     "ProjectReferences": []
   }
 }

src/cpl_query/cpl-query.json

@@ -34,7 +34,10 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {},
+    "PackageData": {
+      "cpl_query": [
+        ".cpl/*.py"
+      ]},
     "ProjectReferences": []
   }
 }

src/cpl_translation/cpl-translation.json

@@ -40,7 +40,10 @@
       "*/logs",
       "*/tests"
     ],
-    "PackageData": {},
+    "PackageData": {
+      "cpl_translation": [
+        ".cpl/*.py"
+      ]},
     "ProjectReferences": []
   }
 }

unittests/unittests_cli/install_test_case.py

@@ -37,11 +37,11 @@ class InstallTestCase(CommandTestCase):
 
         os.chdir(PLAYGROUND_PATH)
         # create projects
-        CLICommands.new('console', self._source, '--ab', '--s')
+        CLICommands.new('console', self._source, '--ab', '--s', '--venv')
         os.chdir(os.path.join(os.getcwd(), self._source))
 
     def _get_installed_packages(self) -> dict:
-        reqs = subprocess.check_output([sys.executable, '-m', 'pip', 'freeze'])
+        reqs = subprocess.check_output([os.path.join(os.getcwd(), 'venv/bin/python'), '-m', 'pip', 'freeze'])
         return dict([tuple(r.decode().split('==')) for r in reqs.split()])
 
     def test_install_package(self):
@@ -50,6 +50,8 @@ class InstallTestCase(CommandTestCase):
         package = f'{package_name}=={version}'
         CLICommands.install(package)
         settings = self._get_project_settings()
+
+        with self.subTest(msg='Project deps'):
             self.assertNotEqual(settings, {})
             self.assertIn('ProjectSettings', settings)
             self.assertIn('Dependencies', settings['ProjectSettings'])
@@ -57,6 +59,8 @@ class InstallTestCase(CommandTestCase):
                 package,
                 settings['ProjectSettings']['Dependencies']
             )
+
+        with self.subTest(msg='PIP'):
             packages = self._get_installed_packages()
             self.assertIn(package_name, packages)
             self.assertEqual(version, packages[package_name])
@@ -67,6 +71,8 @@ class InstallTestCase(CommandTestCase):
         package = f'{package_name}=={version}'
         CLICommands.install(package, is_dev=True)
         settings = self._get_project_settings()
+
+        with self.subTest(msg='Project deps'):
             self.assertNotEqual(settings, {})
             self.assertIn('ProjectSettings', settings)
             self.assertIn('Dependencies', settings['ProjectSettings'])
@@ -79,6 +85,8 @@ class InstallTestCase(CommandTestCase):
                 package,
                 settings['ProjectSettings']['DevDependencies']
             )
+
+        with self.subTest(msg='PIP'):
             packages = self._get_installed_packages()
             self.assertIn(package_name, packages)
             self.assertEqual(version, packages[package_name])
@@ -120,5 +128,3 @@ class InstallTestCase(CommandTestCase):
         packages = self._get_installed_packages()
         self.assertIn(package_name, packages)
         self.assertEqual(version, packages[package_name])
-
-

unittests/unittests_cli/new_test_case.py

@@ -14,10 +14,11 @@ class NewTestCase(CommandTestCase):
         CommandTestCase.__init__(self, method_name)
 
     def _test_project(self, project_type: str, name: str, *args, test_venv=False, without_ws=False):
-        CLICommands.new(project_type, name, *args)
+        CLICommands.new(project_type, name, *args, output=False)
         workspace_path = os.path.abspath(os.path.join(PLAYGROUND_PATH, name))
         self.assertTrue(os.path.exists(workspace_path))
         if test_venv:
+            with self.subTest(msg='Venv exists'):
                 self.assertTrue(os.path.exists(os.path.join(workspace_path, 'venv')))
                 self.assertTrue(os.path.exists(os.path.join(workspace_path, 'venv/bin')))
                 self.assertTrue(os.path.exists(os.path.join(workspace_path, 'venv/bin/python')))
@@ -32,26 +33,38 @@ class NewTestCase(CommandTestCase):
         if without_ws:
             project_path = os.path.abspath(os.path.join(PLAYGROUND_PATH, base, name, 'src/', String.convert_to_snake_case(name)))
 
+        with self.subTest(msg='Project json exists'):
             self.assertTrue(os.path.exists(project_path))
             self.assertTrue(os.path.exists(os.path.join(project_path, f'{name}.json')))
+
+        if project_type == 'library':
+            with self.subTest(msg='Library class1 exists'):
+                self.assertTrue(os.path.exists(os.path.join(project_path, f'class1.py')))
+            return
+
+        with self.subTest(msg='Project main.py exists'):
             self.assertTrue(os.path.exists(os.path.join(project_path, f'main.py')))
 
+        with self.subTest(msg='Application base'):
             if '--ab' in args:
                 self.assertTrue(os.path.isfile(os.path.join(project_path, f'application.py')))
             else:
                 self.assertFalse(os.path.isfile(os.path.join(project_path, f'application.py')))
 
         # s depends on ab
+        with self.subTest(msg='Startup'):
             if '--ab' in args and '--s' in args:
                 self.assertTrue(os.path.isfile(os.path.join(project_path, f'startup.py')))
             else:
                 self.assertFalse(os.path.isfile(os.path.join(project_path, f'startup.py')))
 
+        with self.subTest(msg='Unittest'):
             if project_type == 'unittest':
                 self.assertTrue(os.path.isfile(os.path.join(project_path, f'test_case.py')))
             else:
                 self.assertFalse(os.path.isfile(os.path.join(project_path, f'test_case.py')))
 
+        with self.subTest(msg='Discord'):
             if project_type == 'discord-bot':
                 self.assertTrue(os.path.isfile(os.path.join(project_path, f'events/__init__.py')))
                 self.assertTrue(os.path.isfile(os.path.join(project_path, f'events/on_ready_event.py')))

unittests/unittests_cli/publish_test_case.py

@@ -10,7 +10,6 @@ from unittests_shared.cli_commands import CLICommands
 
 
 class PublishTestCase(CommandTestCase):
-    _skip_tear_down = True
 
     def __init__(self, method_name: str):
         CommandTestCase.__init__(self, method_name)

unittests/unittests_cli/version_test_case.py

@@ -66,6 +66,8 @@ class VersionTestCase(CommandTestCase):
         self._get_version_output(version)
         reference_banner = colored(text2art(self._name), ForegroundColorEnum.yellow.value).split('\n')
         reference_banner = "\n".join(reference_banner[:len(reference_banner) - 1]) + '\n'
+
+        with self.subTest(msg='Block banner'):
             self.assertEqual(reference_banner, self._block_banner)
 
         reference_version = [
@@ -73,15 +75,21 @@ class VersionTestCase(CommandTestCase):
             colored(f'{colored("Python: ")}{colored(f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}")}'),
             colored(f'OS: {colored(f"{platform.system()} {platform.processor()}")}') + '\n'
         ]
+        with self.subTest(msg='Block version'):
             self.assertEqual('\n'.join(reference_version), self._block_version)
         reference_cpl_packages = [
             colored(colored(f'CPL packages:')),
             colored(f'{tabulate(cpl_packages, headers=["Name", "Version"])}') + '\n'
         ]
+        with self.subTest(msg='Block cpl packages'):
             self.assertEqual('\n'.join(reference_cpl_packages), self._block_cpl_packages)
         reference_packages = [
             colored(colored(f'Python packages:')),
             colored(f'{tabulate(packages, headers=["Name", "Version"])}'),
-            '\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m\n' # fix colored codes
+            '\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m\n'  # fix colored codes
         ]
-        self.assertEqual('\n'.join(reference_packages), self._block_packages)
+
+        self.maxDiff = None
+        with self.subTest(msg='Block packages'):
+            ref_packages = '\n'.join(reference_packages)
+            self.assertEqual(ref_packages, self._block_packages)