Changeset 1548

Timestamp:

05/01/08 12:24:21 (23 months ago)

Author:

JensDiemer

Message:

put the plugin preferences into the plugin model.
TODO: update detect_page and set system_settings at install.

Location:

trunk/pylucid/PyLucid

Files:

• db/preferences.py (modified) (2 diffs)
• install/install.py (modified) (1 diff)
• models.py (modified) (7 diffs)
• plugins_internal/find_and_replace/find_and_replace.py (modified) (3 diffs)
• plugins_internal/find_and_replace/find_and_replace_cfg.py (modified) (1 diff)
• plugins_internal/preferences/preferences.py (modified) (4 diffs)
• plugins_internal/search/search.py (modified) (8 diffs)
• plugins_internal/system_settings/system_settings.py (modified) (1 diff)
• system/BasePlugin.py (modified) (1 diff)
• system/detect_page.py (modified) (1 diff)
• system/plugin_import.py (modified) (5 diffs)
• system/plugin_manager.py (modified) (7 diffs)
• tools/newforms_utils.py (added)

trunk/pylucid/PyLucid/db/preferences.py

@@ -4 +4 @@
     PyLucid preferences API
     ~~~~~~~~~~~~~~~~~~~~~~~
+
+    OBSOLETE
 
     Last commit info:
@@ -168 +170 @@
 
 
+def get_pref_dict(plugin_name):
+    """
+    returns the data_dict for the given plugin_name. Used the cache.
+    If a plugin use preferences in a newforms, it must have access to the
+    preferences at module level.
+    FIXME: If the admin change the preferences, the values in a plugin module
+    level would only updated, if the server instance restarted.
+    """
+    if plugin_name in preference_cache:
+        return preference_cache[plugin_name]
+
+    plugin = Plugin.objects.get(plugin_name=plugin_name)
+
+    p = Preferences()
+    p.set_plugin(plugin)
+    p.load_from_db()
+    return p.data_dict
+
 
 #______________________________________________________________________________

trunk/pylucid/PyLucid/install/install.py

@@ -31 +31 @@
     DROP_TABLES = (
         "PyLucid_pagearchiv",
+        "PyLucid_plugin",
+        "PyLucid_preference",
         "PyLucid_preference2",
     )

trunk/pylucid/PyLucid/models.py

@@ -19 +19 @@
 
 import os, posixpath, pickle
+from pprint import pformat
 
 from django.conf import settings
@@ -26 +27 @@
 from django.utils.translation import ugettext as _
 
+from PyLucid.tools.newforms_utils import get_init_dict, setup_help_text
+from PyLucid.tools.data_eval import data_eval, DataEvalError
 from PyLucid.tools.shortcuts import getUniqueShortcut
 from PyLucid.tools import crypt
 from PyLucid.system.utils import get_uri_base
+from PyLucid.system.plugin_import import get_plugin_module
+
 #from PyLucid.db.cache import delete_page_cache
 
@@ -175 +180 @@
         """
         try:
-            entry = Preference.objects.get(name="index page")
-        except Preference.DoesNotExist:
+            preferences = Plugin.objects.get_preferences("system_settings")
+        except Plugin.DoesNotExist, e:
             # Update old PyLucid installation?
             return
 
-        index_page_id = entry.value
+        index_page_id = preferences["index_page"]
 
         if int(self.id) != int(index_page_id):
@@ -224 +229 @@
         """
         try:
-            auto_shortcuts = Preference.objects.get(name='auto shortcuts').value
-        except Preference.DoesNotExist:
+            preferences = Plugin.objects.get_preferences("system_settings")
+        except Plugin.DoesNotExist, e:
             # Update old PyLucid installation?
             auto_shortcuts = True
-
-        if auto_shortcuts in (1, True, "1"):
+        else:
+            print ">>>", preferences
+            auto_shortcuts = preferences["auto_shortcuts"]
+
+        if auto_shortcuts:
             # We should rebuild the shortcut
             self.shortcut = self.name
@@ -485 +493 @@
 
 
-#class Markup(models.Model):
-#    # Obsolete!
-#    pass
-
-#class PagesInternal(models.Model):
-#    # Obsolete!
-#    pass
+class Preference(models.Model):
+    # Obsolete!
+    pass
 
 #____________________________________________________________________
 
+preference_cache = {}
+
+class PluginManager(models.Manager):
+    def get_preferences(self, plugin_name):
+        """
+        returns the preference data dict, use the cache
+        """
+        # Get the name of the plugin, if __file__ used
+        plugin_name = os.path.splitext(os.path.basename(plugin_name))[0]
+        print "plugin name: '%s'" % plugin_name
+
+        if plugin_name in preference_cache:
+            return preference_cache[plugin_name]
+
+        plugin = self.get(plugin_name = plugin_name)
+        return plugin.get_preferences()
+
+
 class Plugin(models.Model):
+    objects = PluginManager()
+
+    plugin_name = models.CharField(max_length=90, unique=True)
+
     package_name = models.CharField(max_length=255)
-    plugin_name = models.CharField(max_length=90, unique=True)
-    version = models.CharField(null=True, blank=True, max_length=45)
     author = models.CharField(blank=True, max_length=150)
     url = models.CharField(blank=True, max_length=255)
     description = models.CharField(blank=True, max_length=255)
-    long_description = models.TextField(blank=True)
+
+    pref_data_string = models.TextField(
+        null=True, blank=True,
+        help_text="printable representation of the newform data dictionary"
+    )
     can_deinstall = models.BooleanField(default=True,
         help_text=(
@@ -512 +540 @@
         help_text="Is this plugin is enabled and useable?"
     )
+
+    def init_pref_form(self, pref_form):
+        """
+        Set self.pref_data_string from the given newforms form and his initial
+        values.
+        """
+        init_dict = get_init_dict(pref_form)
+        preference_cache[self.plugin_name] = init_dict
+        self.set_pref_data_string(init_dict)
+
+    def set_pref_data_string(self, data_dict):
+        """
+        set the dict via pformat
+        """
+        preference_cache[self.plugin_name] = data_dict
+        self.pref_data_string = pformat(data_dict)
+
+    def get_preferences(self):
+        """
+        evaluate the pformat string into a dict and return it.
+        """
+        data_dict = data_eval(self.pref_data_string)
+        preference_cache[self.plugin_name] = data_dict
+        return data_dict
+
+    def get_pref_form(self, debug):
+        """
+        Get the 'PreferencesForm' newform class from the plugin modul, insert
+        initial information into the help text and return the form.
+        """
+        plugin_module = get_plugin_module(
+            self.package_name, self.plugin_name, debug
+        )
+        form = getattr(plugin_module, "PreferencesForm")
+        setup_help_text(form)
+        return form
 
     def save(self):
@@ -535 +599 @@
     class Admin:
         list_display = (
-            "active", "plugin_name", "description", "version", "can_deinstall"
+            "active", "plugin_name", "description", "can_deinstall"
         )
         list_display_links = ("plugin_name",)
         ordering = ('package_name', 'plugin_name')
-        list_filter = ("author",)
+        list_filter = ("author","package_name", "can_deinstall")
 
     def __unicode__(self):
         txt = u"%s - %s" % (self.package_name, self.plugin_name)
         return txt.replace(u"_",u" ")
-
-#______________________________________________________________________________
-# Preference
-
-class Preference(models.Model):
-    """
-    Stores preferences
-
-    Any pickleable Python object can be stored.
-
-    Use a small cache, so the pickle.loads() method would only be used on the
-    first access.
-
-    Note:
-        - This model has no Admin class. Because it makes no sense to edit
-            pickled data strings in the django admin panel ;)
-    """
-    plugin = models.ForeignKey("Plugin", help_text="The associated plugin")
-    repr_string = models.TextField(
-        help_text="printable representation of the newform data dictionary"
-    )
-
-    lastupdatetime = models.DateTimeField(auto_now=True, editable=False)
-    lastupdateby = models.ForeignKey(
-        User, null=True, blank=True, editable=False,
-    )
-
-    #__________________________________________________________________________
-
-    def __unicode__(self):
-        return u"Preference object for '%s'" % self.plugin
-
-    class Admin:
-        pass
-
-    class Meta:
-        # Use a new table
-        db_table = u'PyLucid_preference2'
-
-
-class PreferenceOld(models.Model):
-    """
-    Stores preferences for the PyLucid system and all Plugins.
-
-    Any pickleable Python object can be stored.
-    Use a small cache, so the pickle.loads() method would only be used on the
-    first get_value access. The default_value used no cache.
-
-    Usage:
-    ---------------------------------------------------------------------------
-    Preference(name = "value name", value = my_python_data_object).save()
-
-    p = Preference.objects.get(name = "value name")
-    print p.value
-    ---------------------------------------------------------------------------
-
-    Note:
-        - This model has no Admin class. Because it makes no sense to edit
-            pickled data strings in the django admin panel ;)
-        - value and default_value are properties
-    """
-    __cache = {} # Cache the pickleable Python object
-
-    #__________________________________________________________________________
-
-    def _get_cache_key(self):
-        """ returns plugin name + preferences name as a string """
-        return "%s-%s" % (self.plugin, self.name)
-
-    #__________________________________________________________________________
-    # get and set methods for the value property of the entry
-
-    def __get_value(self):
-        """
-        returns the pickleable Python object back. Use the cache first.
-        """
-        cache_key = self._get_cache_key()
-
-        if cache_key in self.__cache:
-            value = self.__cache[cache_key]
-        else:
-            self._value = str(self._value)
-            value = pickle.loads(self._value)
-            self.__cache[cache_key] = value
-        return value
-
-    def __set_value(self, value):
-        """
-        Save a the pickleable Python object into the database. Remember the
-        source object in the cache
-        """
-        cache_key = self._get_cache_key()
-
-        self.__cache[cache_key] = value
-        self._value = pickle.dumps(value)
-
-    #__________________________________________________________________________
-    # get and set methods for the default value property of the entry
-
-    def __get_default_value(self):
-        """
-        returns the default value back
-        """
-        self._default_value = str(self._default_value)
-        default_value = pickle.loads(self._default_value)
-        return default_value
-
-    def __set_default_value(self, default_value):
-        """
-        save a default value
-        """
-        self._default_value = pickle.dumps(default_value)
-
-    #__________________________________________________________________________
-    # The attributes
-
-    plugin = models.ForeignKey(
-        "Plugin", help_text="The associated plugin",
-        null=True, blank=True, editable=False
-    )
-    name = models.CharField(
-        max_length=150, db_index=True, editable=False,
-        help_text="Name of the preferences entry",
-    )
-    description = models.TextField(editable=False)
-
-    _value = models.TextField(
-        editable=False, help_text="Pickled Python object"
-    )
-    value = property(__get_value, __set_value)
-
-    _default_value = models.TextField(
-        editable=False, help_text="Pickled Python object"
-    )
-    default_value = property(__get_default_value, __set_default_value)
-
-    field_type = models.CharField(max_length=150, editable=False,
-        help_text="The data type for this entry (For building a html form)."
-    )
-
-    lastupdatetime = models.DateTimeField(auto_now=True)
-    lastupdateby = models.ForeignKey(
-        User, null=True, blank=True, editable=False,
-    )
-
-    #__________________________________________________________________________
-
-    def save(self):
-        """
-        Save a new or update a preference entry
-        """
-        if self.id == None:
-            # A new preferences should be saved.
-            if self._default_value == "":
-                # No default value given in the __init__ -> Use current value
-                self._default_value = self._value
-
-        super(Preference, self).save() # Call the "real" save() method
-
-    def __unicode__(self):
-#        <Preference: Preference object>
-        return "%s '%s'" % (self.plugin, self.name)
-
-    class Meta:
-        # Use the old table
-        db_table = u'PyLucid_preference'
 
 

trunk/pylucid/PyLucid/plugins_internal/find_and_replace/find_and_replace.py

@@ -29 +29 @@
 
 from django import newforms as forms
+from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
-from django.utils.safestring import mark_safe
 
+from PyLucid.system.BasePlugin import PyLucidBasePlugin
 from PyLucid.models import Page, Template, Style
-from PyLucid.system.BasePlugin import PyLucidBasePlugin
+#from PyLucid.db.preferences import get_pref_dict
+from PyLucid.tools.Diff import diff_lines
 from PyLucid.tools.utils import escape
-from PyLucid.tools.Diff import diff_lines
 
-# How min/max long must a search term be?
-MIN_TERM_LEN = 2
-MAX_TERM_LEN = 150
 
 class PreferencesForm(forms.Form):
@@ -59 +57 @@
 )
 
+
+# We used preferences values in a newform. We need these values here.
+try:
+    preferences = Plugin.objects.get_preferences(__file__)
+except Plugin.DoesNotExist, e:
+    # in _install section?
+    pass
+else:
+    min_term_len = preferences["min_term_len"]
+    max_term_len = preferences["max_term_len"]
+
+
 class FindReplaceForm(forms.Form):
     # TODO: min und max should be saved in the prefereces.
     find_string = forms.CharField(
-        min_length = MIN_TERM_LEN, max_length = MAX_TERM_LEN,
+        min_length = min_term_len, max_length = max_term_len,
     )
     replace_string = forms.CharField(
-        min_length = MIN_TERM_LEN, max_length = MAX_TERM_LEN,
+        min_length = min_term_len, max_length = max_term_len,
     )
     type = forms.ChoiceField(
@@ -79 +89 @@
 
     def find_and_replace(self):
-        self.page_msg("Preferences:", self.preferences)
-
         context = {}
         if self.request.method == 'POST':

trunk/pylucid/PyLucid/plugins_internal/find_and_replace/find_and_replace_cfg.py

@@ -26 +26 @@
     },
 }
+
+preferences = (
+    {
+        "name": "term len limit",
+        "description": "How min/max long must a search term be?",
+        "value": {
+            "min term len": 1,
+            "max term len": 255,
+        }
+    },
+)

trunk/pylucid/PyLucid/plugins_internal/preferences/preferences.py

@@ -26 +26 @@
 from django.utils.translation import ugettext as _
 
-from PyLucid.db.preferences import get_all_prefs, Preferences
 from PyLucid.system.BasePlugin import PyLucidBasePlugin
-from PyLucid.tools.data_eval import data_eval, DataEvalError
+from PyLucid.models import Plugin
 
 
@@ -44 +43 @@
 
         items = []
-        for pref in get_all_prefs():
-            edit_link = self.URLs.methodLink("edit", args=pref.id)
+        plugins = Plugin.objects.all()
+        for plugin in plugins:
+            if plugin.pref_data_string == None:
+                continue
+
+            edit_link = self.URLs.methodLink("edit", args=plugin.id)
 
             items.append({
-                "plugin_name": self._vebose_plugin_name(pref),
-                "plugin_description": pref.plugin.description,
+                "plugin_name": unicode(plugin),
+                "plugin_description": plugin.description,
                 "edit_link": edit_link,
             })
@@ -62 +65 @@
         try:
             url_args = url_args.strip("/")
-            pref_id = int(url_args)
+            plugin_id = int(url_args)
         except Exception, e:
             self.page_msg.red("url error:", e)
             return
 
-        p = Preferences()
-        p.init_via_id(pref_id)
-        data_dict = p.data_dict
-
-        p.load_form(self.request)
-        unbound_form = p.form
+        plugin = Plugin.objects.get(id = plugin_id)
+        unbound_form = plugin.get_pref_form(self.request.debug)
 
         if self.request.method == 'POST':
@@ -78 +77 @@
             if form.is_valid():
                 new_data_dict = form.cleaned_data
-                p.update_and_save(new_data_dict)
+
+                plugin.set_pref_data_string(new_data_dict)
+                plugin.save()
                 self.page_msg("New preferences saved.")
                 return self.select() # Display the menu
         else:
+            data_dict = plugin.get_preferences()
             form = unbound_form(data_dict)
 
         context = {
-            "plugin_name": self._vebose_plugin_name(p),
+            "plugin_name": unicode(plugin),
             "form": form,
             "url_abort": self.URLs.methodLink("select"),

trunk/pylucid/PyLucid/plugins_internal/search/search.py

@@ -27 +27 @@
 
 from django import newforms as forms
+from django.utils.safestring import mark_safe
 from django.utils.translation import ugettext as _
-from django.utils.safestring import mark_safe
-
-from PyLucid.models import Page
+
 from PyLucid.system.BasePlugin import PyLucidBasePlugin
 from PyLucid.tools.utils import escape
-
-
-# How min/max long must a search term be?
-MIN_TERM_LEN = 3
-MAX_TERM_LEN = 50
-
-# Number of the paged for the result page:
-MAX_RESULTS = 20
-
-# The length of the text-hit-cutouts:
-TEXT_CUTOUT_LEN = 50
-
-# Max. cutout lines for every search term:
-MAX_CUTOUTS_LINES = 5
+from PyLucid.models import Page, Plugin
 
 
@@ -71 +57 @@
     )
 
-
-class SearchForm(forms.Form):
-    # TODO: min und max should be saved in the prefereces.
-    search_string = forms.CharField(
-        min_length = MIN_TERM_LEN, max_length = MAX_TERM_LEN
-    )
+# We used preferences values in a newform. We need these values here.
+try:
+    preferences = Plugin.objects.get_preferences(__file__)
+except Plugin.DoesNotExist, e:
+    # in _install section?
+    pass
+else:
+    class SearchForm(forms.Form):
+        search_string = forms.CharField(
+            min_length = preferences["min_term_len"],
+            max_length = preferences["max_term_len"],
+        )
 
 
@@ -85 +77 @@
         Insert a empty search form into the page.
         """
-        self.page_msg("Preferences:", self.preferences)
         search_form = SearchForm()
         context = {
@@ -138 +129 @@
         search_strings = []
         for term in raw_search_strings:
-            if len(term)<MIN_TERM_LEN:
+            if len(term)<preferences["min_term_len"]:
                 self.page_msg("Ignore '%s' (too small)" % cgi.escape(term))
             else:
@@ -178 +169 @@
 
         # Use only the first pages:
-        results = results[:MAX_RESULTS]
+        results = results[:preferences["max_results"]]
 
         # Build a dict, for the template
@@ -191 +182 @@
         the lines.
         """
+        text_cutout_len = preferences["text_cutout_len"]
+        max_cutout_lines = preferences["max_cutout_lines"]
+
         for result in results:
             result["cutouts"] = []
@@ -197 +191 @@
             for term in search_strings:
                 start = 0
-                for _ in xrange(MAX_CUTOUTS_LINES):
+                for _ in xrange(max_cutout_lines):
                     try:
                         index = content.index(term, start)
@@ -206 +200 @@
                     start = index+1
 
-                    if index<TEXT_CUTOUT_LEN:
-                        txt = content[:TEXT_CUTOUT_LEN]
+                    if index<text_cutout_len:
+                        txt = content[:text_cutout_len]
                     else:
-                        txt = content[index-TEXT_CUTOUT_LEN:index+TEXT_CUTOUT_LEN]
+                        start = index-text_cutout_len
+                        end = index+text_cutout_len
+                        txt = content[start:end]
 
                     txt = escape(txt)

trunk/pylucid/PyLucid/plugins_internal/system_settings/system_settings.py

@@ -60 +60 @@
         Insert a empty search form into the page.
         """
-        self.page_msg("Preferences:", self.preferences)
+        self.page_msg("Preferences:", preferences)

trunk/pylucid/PyLucid/system/BasePlugin.py

@@ -59 +59 @@
 
         self.current_page = self.context["PAGE"]
-        self.preferences = self.context.preferences
 
     def build_menu(self):

trunk/pylucid/PyLucid/system/detect_page.py

@@ -17 +17 @@
 """
 
-from PyLucid.models import Page, Preference
+from PyLucid.models import Page
 from PyLucid.system.exceptions import AccessDenied, LowLevelError
 

trunk/pylucid/PyLucid/system/plugin_import.py

@@ -21 +21 @@
 
 
-def _import(request, from_name, object_name):
+def _import(from_name, object_name, debug):
     """
     from 'from_name' import 'object_name'
@@ -28 +28 @@
         return __import__(from_name, {}, {}, [object_name])
     except (ImportError, SyntaxError), e:
-        if request.user.is_superuser or request.debug:
+        if debug:
             raise
         raise ImportError, "Can't import %s from %s: %s" % (
@@ -34 +34 @@
         )
 
-def get_plugin_module(request, package_name, plugin_name):
-    plugin_module = _import(request,
+def get_plugin_module(package_name, plugin_name, debug):
+    plugin_module = _import(
         from_name = ".".join([package_name, plugin_name, plugin_name]),
-        object_name = plugin_name
+        object_name = plugin_name,
+        debug = debug,
     )
     return plugin_module
 
-#def get_plugin_class(request, package_name, plugin_name):
-#    """
-#    import the plugin/plugin and returns the class object
-#    """
-#    plugin_module = get_plugin_module(request, package_name, plugin_name)
-#    plugin_class = getattr(plugin_module, plugin_name)
-#    return plugin_class
+#    debug = request.user.is_superuser or request.debug
+
 
 def debug_plugin_config(page_msg, plugin_config):
@@ -65 +61 @@
     """
     config_name = "%s_cfg" % plugin_name
+    debug = request.user.is_superuser or request.debug
 
     def get_plugin(object_name):
@@ -70 +67 @@
         if extra_verbose:
             print "from %s import %s" % (from_name, object_name)
-        return _import(request, from_name, object_name)
+        return _import(from_name, object_name, debug)
 
     config_plugin = get_plugin(config_name)

trunk/pylucid/PyLucid/system/plugin_manager.py

@@ -34 +34 @@
 from django.http import HttpResponse, Http404
 
-from PyLucid.db.preferences import Preferences, preference_cache, \
-                                                        PreferenceDoesntExist
+#from PyLucid.db.preferences import Preferences, preference_cache, PreferenceDoesntExist
 from PyLucid.system.plugin_import import get_plugin_module, get_plugin_config
 from PyLucid.system.exceptions import *
@@ -112 +111 @@
     URLs.current_plugin = plugin_name
 
-    plugin_module = get_plugin_module(request, plugin.package_name, plugin_name)
-
-    if plugin_name in preference_cache:
-        context.preferences = preference_cache[plugin_name]
-    else:
-        if hasattr(plugin_module, "PreferencesForm"):
-            # Get the preferences dict data from the database
-            try:
-                p = Preferences()
-                p.set_plugin(plugin)
-                p.load_from_db()
-                context.preferences = p.data_dict
-            except PreferenceDoesntExist, e:
-                error("Can't get preferences: %s" % e)
-                return
-        else:
-            # plugin has no preferences
-            context.preferences = None
+    debug = request.user.is_superuser or request.debug
+    plugin_module = get_plugin_module(plugin.package_name, plugin_name, debug)
 
     plugin_class = getattr(plugin_module, plugin_name)
+#    print plugin_class, type(plugin_class)
     class_instance = plugin_class(context, local_response)
     unbound_method = getattr(class_instance, method_name)
@@ -216 +200 @@
 
 
-def _install_plugin(package_name, plugin_name, plugin_config, active,
+def _install_plugin(request, package_name, plugin_name, plugin_config, active,
                                                                 extra_verbose):
     """
@@ -223 +207 @@
     if extra_verbose:
         print "Install %s.%s..." % (package_name, plugin_name),
+
     plugin = Plugin.objects.create(
         package_name = package_name,
         plugin_name = plugin_name,
-        version = plugin_config.__version__,
         author = plugin_config.__author__,
         url = plugin_config.__url__,
         description = plugin_config.__description__,
-        long_description = plugin_config.__long_description__,
         can_deinstall = getattr(plugin_config, "__can_deinstall__", True),
         active = active,
     )
+    debug = request.user.is_superuser or request.debug
+    plugin_module = get_plugin_module(package_name, plugin_name, debug)
+    pref_form = getattr(plugin_module, "PreferencesForm", None)
+    if pref_form:
+        # plugin module has a preferences newform class
+        plugin.init_pref_form(pref_form)
+
+
     plugin.save()
     if extra_verbose:
@@ -239 +230 @@
     return plugin
 
-
-def _insert_preferences(request, plugin, package_name, plugin_name):
-    """
-    insertet the initial values from the newforms preferences class into the
-    database.
-    """
-    plugin_module = get_plugin_module(request, package_name, plugin_name)
-
-    pref_form = getattr(plugin_module, "PreferencesForm", None)
-    if pref_form == None:
-        # Has no preferences newform class
-        return
-
-    p = Preferences()
-    p.set_plugin(plugin)
-    p.create_initial(pref_form)
 
 
@@ -280 +255 @@
 
     plugin = _install_plugin(
-        package_name, plugin_name, plugin_config, active, extra_verbose
+        request, package_name, plugin_name,
+        plugin_config, active, extra_verbose
     )
-    _insert_preferences(request, plugin, package_name, plugin_name)
 
 
@@ -314 +289 @@
             )
         except Exception, e:
-            print "Error:", e
+            print "Error:"
+            import traceback
+            traceback.print_exc()
             continue