GwRecipesPattern.__init__() - Code Metrics - Inspection of "Merge branch 'recipes' of https://github.com/usebl..." - useblocks/groundwork - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6fd567...f65269 )

by Daniel

created 2016-09-09 09:23 UTC

GwRecipesPattern.init() A

↳ Parent: GwRecipesPattern

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
cc	2
c	4
b	0
f	0
dl	0
loc	8
rs	9.4285

"""
Groundwork recipe pattern.

Provides function to register, get and build recipes.

Recipes are used create directories and files based on a given template and some user input.
It is mostly used to speed up the set up of new python packages, groundwork applications or projects.

Based on cookiecutter: https://github.com/audreyr/cookiecutter/
"""
import os
import logging
from cookiecutter.main import cookiecutter

from groundwork.patterns.gw_base_pattern import GwBasePattern


class GwRecipesPattern(GwBasePattern):

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        if not hasattr(self.app, "recipes"):
            self.app.recipes = RecipesListApplication(self.app)

        #: Stores an instance of :class:`~groundwork.patterns.gw_recipes_pattern.RecipesListPlugin`
        self.recipes = RecipesListPlugin(self)

    # register new recipe (aka template)
    # get recipes


class RecipesListPlugin:

    """
    Cares about the recipe management on plugin level.
    Allows to register, get and build recipes in the context of the current plugin.

    :param plugin: plugin, which shall be used as contxt.
    """
    def __init__(self, plugin):
        self._plugin = plugin
        self.__app = plugin.app
        self.__log = plugin.log

        # Let's register a receiver, which cares about the deactivation process of recipes for this plugin.
        # We do it after the original plugin deactivation, so we can be sure that the registered function is the last
        # one which cares about recipes for this plugin.
        self._plugin.signals.connect(receiver="%s_recipes_deactivation" % self._plugin.name,
                                     signal="plugin_deactivate_post",
                                     function=self.__deactivate_recipes,
                                     description="Deactivate recipes for %s" % self._plugin.name,
                                     sender=self._plugin)
        self.__log.debug("Plugin recipes initialised")

    def __deactivate_recipes(self, plugin, *args, **kwargs):
        """
        Deactivates/unregisters all recipes of the current plugin, if this plugin gets deactivated.
        """
        recipes = self.get()
        for recipe in recipes.keys():
            self.unregister(recipe)

    def register(self, name, path, description, final_words=None):
        """
        Registers a new recipe in the context of the current plugin.

        :param name: Name of the recipe
        :param path: Absolute path of the recipe folder
        :param description: A meaningful description of the recipe
        :param final_words: A string, which gets printed after the recipe was build.
        """
        return self.__app.recipes.register(name, path, self._plugin, description, final_words)

    def unregister(self, recipe):
        """
        Unregister a recipe of the current plugin.

        :param recipe: Name of the recipe.
        """
        return self.__app.recipes.unregister(recipe)

    def get(self, name=None):
        """
        Gets a list of all recipes, which are registered by the current plugin.
        If a name is provided, only the requested recipe is returned or None.

        :param: name: Name of the recipe
        """
        return self.__app.recipes.get(name, self._plugin)

    def build(self, recipe):
        """
        Builds a recipe

        :param recipe: Name of the recipe to build.
        """
        return self.__app.recipes.build(recipe, self._plugin)


class RecipesListApplication:
    """
    Cares about the recipe management on application level.
    Allows to register, get and build recipes.

    :param app: groundwork application instance
    """
    def __init__(self, app):
        self.__app = app
        self.recipes = {}
        self.__log = logging.getLogger(__name__)
        self.__log.info("Application recipes initialised")

    def register(self, name, path, plugin, description=None, final_words=None):
        """
        Registers a new recipe.
        """
        if name in self.recipes.keys():
            raise RecipeExistsException("Recipe %s was already registered by %s" %
                                        (name, self.recipes["name"].plugin.name))

        self.recipes[name] = Recipe(name, path, plugin, description, final_words)
        self.__log.debug("Recipe %s registered by %s" % (name, plugin.name))
        return self.recipes[name]

    def unregister(self, recipe):
        """
        Unregisters an existing recipe, so that this recipe is no longer available.

        This function is mainly used during plugin deactivation.

        :param recipe: Name of the recipe
        """
        if recipe not in self.recipes.keys():
            self.__log.warning("Can not unregister recipe %s" % recipe)
        else:
            del (self.recipes[recipe])
            self.__log.debug("Recipe %s got unregistered" % recipe)

    def get(self, recipe=None, plugin=None):

        """
        Get one or more recipes.

        :param recipe: Name of the recipe
        :type recipe: str
        :param plugin: Plugin object, under which the recipe where registered
        :type plugin: GwBasePattern
        """
        if plugin is not None:
            if recipe is None:
                recipes_list = {}
                for key in self.recipes.keys():
                    if self.recipes[key].plugin == plugin:
                        recipes_list[key] = self.recipes[key]
                return recipes_list
            else:
                if recipe in self.recipes.keys():
                    if self.recipes[recipe].plugin == plugin:
                        return self.recipes[recipe]
                    else:
                        return None
                else:
                    return None
        else:
            if recipe is None:
                return self.recipes
            else:
                if recipe in self.recipes.keys():
                    return self.recipes[recipe]
                else:
                    return None

    def build(self, recipe, plugin=None):
        """
        Execute a recipe and creates new folder and files.

        :param recipe: Name of the recipe
        :param plugin: Name of the plugin, to which the recipe must belong.
        """
        if recipe not in self.recipes.keys():
            raise RecipeMissingException("Recipe %s unknown." % recipe)

        recipe_obj = self.recipes[recipe]

        if plugin is not None:
            if recipe_obj.plugin != plugin:
                raise RecipeWrongPluginException("The requested recipe does not belong to the given plugin. Use"
                                                 "the app object, to retrieve the requested recipe: "
                                                 "my_app.recipes.get(%s)" % recipe)

        recipe_obj.build()


class Recipe:
    """
    A recipe is an existing folder, which will be handled by the underlying cookiecutter library as template folder.

    :param name: Name of the recipe
    :param path: Absolute path to the recipe folder
    :param plugin: Plugin which registers the recipe
    :param description: Meaningful description of the recipe
    :param final_words: String, which gets printed after a recipe was successfully build.
    """
    def __init__(self, name, path, plugin, description="", final_words=""):
        self.name = name
        if os.path.isabs(path):
            self.path = path
        else:
            raise FileNotFoundError("Path of recipe must be absolute. Got %s" % path)
        self.plugin = plugin
        self.description = description
        self.final_words = final_words

    def build(self, output_dir=None, **kwargs):
        """
        Buildes the recipe and creates needed folder and files.
        May ask the user for some parameter inputs.

        :param output_dir: Path, where the recipe shall be build. Default is the current working directory
        :return: location of the installed recipe
        """
        if output_dir is None:
            output_dir = os.getcwd()

        target = cookiecutter(self.path, output_dir=output_dir, **kwargs)

        if self.final_words is not None and len(self.final_words) > 0:
            print("")
            print(self.final_words)
        return target


class RecipeExistsException(BaseException):
    pass


class RecipeMissingException(BaseException):
    pass


class RecipeWrongPluginException(BaseException):
    pass


1		"""
2		Groundwork recipe pattern.
3
4		Provides function to register, get and build recipes.
5
6		Recipes are used create directories and files based on a given template and some user input.
7		It is mostly used to speed up the set up of new python packages, groundwork applications or projects.
8
9		Based on cookiecutter: https://github.com/audreyr/cookiecutter/
10		"""
11		import os
12		import logging
13		from cookiecutter.main import cookiecutter
14
15		from groundwork.patterns.gw_base_pattern import GwBasePattern
16
17
18		class GwRecipesPattern(GwBasePattern):
19
20		def __init__(self, args, *kwargs):
21		super().__init__(args, *kwargs)
22
23		if not hasattr(self.app, "recipes"):
24		self.app.recipes = RecipesListApplication(self.app)
25
26		#: Stores an instance of :class:`~groundwork.patterns.gw_recipes_pattern.RecipesListPlugin`
27		self.recipes = RecipesListPlugin(self)
28
29		# register new recipe (aka template)
30		# get recipes
31
32
33	View Code Duplication	class RecipesListPlugin:
		0 ignored issues – show Duplication introduced 2016-09-09 10:53 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
34		"""
35		Cares about the recipe management on plugin level.
36		Allows to register, get and build recipes in the context of the current plugin.
37
38		:param plugin: plugin, which shall be used as contxt.
39		"""
40		def __init__(self, plugin):
41		self._plugin = plugin
42		self.__app = plugin.app
43		self.__log = plugin.log
44
45		# Let's register a receiver, which cares about the deactivation process of recipes for this plugin.
46		# We do it after the original plugin deactivation, so we can be sure that the registered function is the last
47		# one which cares about recipes for this plugin.
48		self._plugin.signals.connect(receiver="%s_recipes_deactivation" % self._plugin.name,
49		signal="plugin_deactivate_post",
50		function=self.__deactivate_recipes,
51		description="Deactivate recipes for %s" % self._plugin.name,
52		sender=self._plugin)
53		self.__log.debug("Plugin recipes initialised")
54
55		def __deactivate_recipes(self, plugin, args, *kwargs):
56		"""
57		Deactivates/unregisters all recipes of the current plugin, if this plugin gets deactivated.
58		"""
59		recipes = self.get()
60		for recipe in recipes.keys():
61		self.unregister(recipe)
62
63		def register(self, name, path, description, final_words=None):
64		"""
65		Registers a new recipe in the context of the current plugin.
66
67		:param name: Name of the recipe
68		:param path: Absolute path of the recipe folder
69		:param description: A meaningful description of the recipe
70		:param final_words: A string, which gets printed after the recipe was build.
71		"""
72		return self.__app.recipes.register(name, path, self._plugin, description, final_words)
73
74		def unregister(self, recipe):
75		"""
76		Unregister a recipe of the current plugin.
77
78		:param recipe: Name of the recipe.
79		"""
80		return self.__app.recipes.unregister(recipe)
81
82		def get(self, name=None):
83		"""
84		Gets a list of all recipes, which are registered by the current plugin.
85		If a name is provided, only the requested recipe is returned or None.
86
87		:param: name: Name of the recipe
88		"""
89		return self.__app.recipes.get(name, self._plugin)
90
91		def build(self, recipe):
92		"""
93		Builds a recipe
94
95		:param recipe: Name of the recipe to build.
96		"""
97		return self.__app.recipes.build(recipe, self._plugin)
98
99
100		class RecipesListApplication:
101		"""
102		Cares about the recipe management on application level.
103		Allows to register, get and build recipes.
104
105		:param app: groundwork application instance
106		"""
107		def __init__(self, app):
108		self.__app = app
109		self.recipes = {}
110		self.__log = logging.getLogger(__name__)
111		self.__log.info("Application recipes initialised")
112
113		def register(self, name, path, plugin, description=None, final_words=None):
114		"""
115		Registers a new recipe.
116		"""
117		if name in self.recipes.keys():
118		raise RecipeExistsException("Recipe %s was already registered by %s" %
119		(name, self.recipes["name"].plugin.name))
120
121		self.recipes[name] = Recipe(name, path, plugin, description, final_words)
122		self.__log.debug("Recipe %s registered by %s" % (name, plugin.name))
123		return self.recipes[name]
124
125		def unregister(self, recipe):
126		"""
127		Unregisters an existing recipe, so that this recipe is no longer available.
128
129		This function is mainly used during plugin deactivation.
130
131		:param recipe: Name of the recipe
132		"""
133		if recipe not in self.recipes.keys():
134		self.__log.warning("Can not unregister recipe %s" % recipe)
135		else:
136		del (self.recipes[recipe])
137		self.__log.debug("Recipe %s got unregistered" % recipe)
138
139	View Code Duplication	def get(self, recipe=None, plugin=None):
		0 ignored issues – show Duplication introduced 2016-09-09 10:53 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
140		"""
141		Get one or more recipes.
142
143		:param recipe: Name of the recipe
144		:type recipe: str
145		:param plugin: Plugin object, under which the recipe where registered
146		:type plugin: GwBasePattern
147		"""
148		if plugin is not None:
149		if recipe is None:
150		recipes_list = {}
151		for key in self.recipes.keys():
152		if self.recipes[key].plugin == plugin:
153		recipes_list[key] = self.recipes[key]
154		return recipes_list
155		else:
156		if recipe in self.recipes.keys():
157		if self.recipes[recipe].plugin == plugin:
158		return self.recipes[recipe]
159		else:
160		return None
161		else:
162		return None
163		else:
164		if recipe is None:
165		return self.recipes
166		else:
167		if recipe in self.recipes.keys():
168		return self.recipes[recipe]
169		else:
170		return None
171
172		def build(self, recipe, plugin=None):
173		"""
174		Execute a recipe and creates new folder and files.
175
176		:param recipe: Name of the recipe
177		:param plugin: Name of the plugin, to which the recipe must belong.
178		"""
179		if recipe not in self.recipes.keys():
180		raise RecipeMissingException("Recipe %s unknown." % recipe)
181
182		recipe_obj = self.recipes[recipe]
183
184		if plugin is not None:
185		if recipe_obj.plugin != plugin:
186		raise RecipeWrongPluginException("The requested recipe does not belong to the given plugin. Use"
187		"the app object, to retrieve the requested recipe: "
188		"my_app.recipes.get(%s)" % recipe)
189
190		recipe_obj.build()
191
192
193		class Recipe:
194		"""
195		A recipe is an existing folder, which will be handled by the underlying cookiecutter library as template folder.
196
197		:param name: Name of the recipe
198		:param path: Absolute path to the recipe folder
199		:param plugin: Plugin which registers the recipe
200		:param description: Meaningful description of the recipe
201		:param final_words: String, which gets printed after a recipe was successfully build.
202		"""
203		def __init__(self, name, path, plugin, description="", final_words=""):
204		self.name = name
205		if os.path.isabs(path):
206		self.path = path
207		else:
208		raise FileNotFoundError("Path of recipe must be absolute. Got %s" % path)
209		self.plugin = plugin
210		self.description = description
211		self.final_words = final_words
212
213		def build(self, output_dir=None, **kwargs):
214		"""
215		Buildes the recipe and creates needed folder and files.
216		May ask the user for some parameter inputs.
217
218		:param output_dir: Path, where the recipe shall be build. Default is the current working directory
219		:return: location of the installed recipe
220		"""
221		if output_dir is None:
222		output_dir = os.getcwd()
223
224		target = cookiecutter(self.path, output_dir=output_dir, **kwargs)
225
226		if self.final_words is not None and len(self.final_words) > 0:
227		print("")
228		print(self.final_words)
229		return target
230
231
232		class RecipeExistsException(BaseException):
233		pass
234
235
236		class RecipeMissingException(BaseException):
237		pass
238
239
240		class RecipeWrongPluginException(BaseException):
241		pass
242

useblocks / groundwork

Push — master ( 6fd567...f65269 )

GwRecipesPattern.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

GwRecipesPattern.init() A