def generate_usable_slug(recipe):
    """
    Generate a usable slug for a given recipe. This method will try to slugify
    the recipe name and then append an integer if needed, increasing this
    integer until no existing recipe would be overwritten.
    """
    slug = slugify(recipe.name)

    # Reuse existing slug if we can
    if recipe.slug and recipe.slug == slug:
        return recipe.slug

    append = 0
    while True:
        count = Recipe.all()\
                      .filter('owner =', recipe.owner)\
                      .filter('slug =', slug)\
                      .count()

        if not count:
            break

        append += 1
        slug = slugify(recipe.name) + str(append)

    return slug

def generate_usable_slug(brew):
    """
    Generate a usable slug for a given brew. This method will try to slugify
    the brew date + owner and then append an integer if needed, increasing this
    integer until no existing brew would be overwritten.
    """
    base = brew.started.strftime('%d-%b-%Y') + '-' + brew.owner.name
    slug = slugify(base)

    # Reuse existing slug if we can
    if brew.slug and brew.slug == slug:
        return brew.slug

    append = 0
    while True:
        count = Brew.all()\
                    .filter('owner =', brew.owner)\
                    .filter('recipe =', brew.recipe)\
                    .filter('slug =', slug)\
                    .count()

        if not count:
            break

        append += 1
        slug = slugify(base) + str(append)

    return slug

def _smart(url, tries):
    # let's get the content of the page
    soup = BeautifulSoup(urllib2.urlopen(url))

    # we want to build a short with the page title
    if soup.title is None:
        return _random(url)

    title = soup.title.string
    if title is None:
        return _random(url)

    words = [word.lower() for word in
                [word.strip() for word in title.split()]
                if len(word) > 4 and word[0] != '&']

    # that works for Sphinx :)
    if len(words) > 1:
        short = words[0] + '-' + words[1]
    elif len(words) == 1:
        short = words[0]
    else:
        return _random(url)

    if tries > 0:
        short += '-' + str(tries)

    return slugify(short)

    def __init__(self, module_path):
        self.module_path = module_path
        self.filename    = filename = os.path.basename(module_path)

        module_name = filename.split('.')[0].lstrip('_01234567890')

        imp_desc  = ('', 'r', imp.PY_SOURCE)
        with open(module_path) as module_file:
            self.module     = imp.load_module(module_name, module_file, module_path, imp_desc)
            module_file.seek(0)
            self.module_src = module_file.read()

        self.title    = self.module.title
        self.author   = self.module.author # TODO: settings.AUTHORS lookup
        self.tags     = getattr(self.module,'tags',())
        self.is_draft = getattr(self.module,'draft',False)
        self.pub_date = datetime.datetime(*self.module.pub_date)

        updated = getattr(self.module, 'updated', self.pub_date)
        self.updated  = updated or datetime.datetime(*updated)

        try:
            self.id = int(getattr(self.module, int_id_name, None))
        except ValueError:
            raise ValueError('Internal IDs should be integers.'+str(file_path))
        
        self.slug     = slugify(unicode(self.title))

        self.parts    = get_parts(self.module_src)

        self.run_examples()

def handle_error(e):
    if not e:
        e = {}
    else:
        logging.exception(e)

    try:
        e.code
    except AttributeError:
        e.code = 500
        e.name = e.description = 'Internal Server Error'
    result = {
        'status': 'error',
        'error_code': e.code,
        'error_name': util.slugify(e.name),
        'error_message': e.name,
        'error_class': e.__class__.__name__,
        'description': e.description,
        'data': None,
        'validations': None
    }
    if hasattr(e, 'data'):
        result['data'] = e.data
    if hasattr(e, 'validations'):
        result['validations'] = e.validations
    return util.jsonpify(result), e.code

def clone_infra(plan, environment, name, team, project, description, task=None, clone=None):
    if not plan.provider == plan.CLOUDSTACK:
        dbinfra = DatabaseInfra.best_for(
            plan=plan, environment=environment, name=name)

        if dbinfra:
            database = Database.provision(databaseinfra=dbinfra, name=name)
            database.team = team
            database.description = description
            database.project = project
            database.save()

            return build_dict(databaseinfra=dbinfra, database=database, created=True)

        return build_dict(databaseinfra=None, created=False)

    workflow_dict = build_dict(name=slugify(name),
                               plan=plan,
                               environment=environment,
                               steps=get_clone_settings(plan.engine_type.name),
                               qt=get_vm_qt(plan=plan, ),
                               dbtype=str(plan.engine_type),
                               team=team,
                               project=project,
                               description=description,
                               clone=clone
                               )

    start_workflow(workflow_dict=workflow_dict, task=task)
    return workflow_dict

def error_handler(e):
    logging.exception(e)
    try:
        e.code
    except AttributeError:
        e.code = 500
        e.name = "Internal Server Error"

    if flask.request.path.startswith("/_s/"):
        return (
            util.jsonpify(
                {
                    "status": "error",
                    "error_code": e.code,
                    "error_name": util.slugify(e.name),
                    "error_message": e.name,
                    "error_class": e.__class__.__name__,
                }
            ),
            e.code,
        )

    return (
        flask.render_template(
            "error.html", title="Error %d (%s)!!1" % (e.code, e.name), html_class="error-page", error=e
        ),
        e.code,
    )

    def clean(self):
        #slugify name
        if not self.pk:
            # new database
            self.name = slugify(self.name)

        if self.name in self.__get_database_reserved_names():
            raise ValidationError(_("%s is a reserved database name" % self.name))

 def render_author_pages(self):
     author_dict = self.author_dict
     for author, posts in author_dict.items():
         author_slug = slugify(unicode(author))
         with open(os.path.join(OUTPUT_DIR, 'author', author_slug+'.html'), 'w') as a_file:
             a_file.write(render_to('post_list.html', 
                                    posts=posts, 
                                    list_desc="Posts by "+author+""))

 def _build_globo(self, channel=None):
     categories, shows = scraper.get_globo_shows()
     data = { 'globo': {} }
     for cat, show_list in zip(categories, shows):
         slug = util.slugify(cat)
         data['globo'].update({slug: (cat, None)})
         data[slug] = show_list
     return data

 def __init__(self, index, display, interface, change=2, data_rate=64):
     self.index = index
     self.display = display
     self.id = util.slugify(display)
     self.change = change
     self.data_rate = data_rate
     self.interface = interface
     self.logger = util.get_logger("%s.%s" % (self.__module__, self.__class__.__name__))

 def add_post(self, title, post, tags):
     url = slugify(title)
     self.collection.save(dict(title=title,
                               post=post,
                               tags=tags,
                               comments=[],
                               time=datetime.now(),
                               url=url)
     )

def get_globo_shows():
    soup = bs(get_page(GLOBOTV_MAIS_URL))
    content = soup.findAll('div', attrs={'class': re.compile('trilho-tag')})
    categories = [c.find('h2').text for c in content]
    shows = [dict([(util.slugify(img['alt']),
                    (img['alt'],
                     img['data-src'].replace(img['data-src'][7:img['data-src'].index('=/')+2], '')))
                    for img in c.findAll('img') if '=/' in img['data-src']])
             for c in content]
    return (categories, shows)

 def create_new_credential(cls, user, database):
     credential = Credential()
     credential.database = database
     credential.user = user[:cls.USER_MAXIMUM_LENGTH_NAME]
     credential.user = slugify(credential.user)
     credential.password = make_db_random_password()
     credential.full_clean()
     credential.driver.create_user(credential)
     credential.save()
     return credential

    def clean(self):
        if not self.pk:
            self.name = slugify(self.name)

        if self.name in self.__get_database_reserved_names():
            raise ValidationError(
                _("{} is a reserved database name".format(
                    self.name
                ))
            )

def database_pre_save(sender, **kwargs):
    database = kwargs.get('instance')

    #slugify name
    database.name = slugify(database.name)

    if database.id:
        saved_object = Database.objects.get(id=database.id)
        if database.name != saved_object.name:
            raise AttributeError(_("Attribute name cannot be edited"))

    def render_tag_pages(self):
        tag_dict = self.tag_dict
        for tag, posts in tag_dict.items():
            tag_slug = slugify(unicode(tag))
            with open(os.path.join(OUTPUT_DIR, 'tag', tag_slug+'.html'), 'w') as t_file:
                t_file.write(render_to('post_list.html', 
                                       posts=posts, 
                                       list_desc="Posts tagged <em>"+tag+"</em>"))

        with open(os.path.join(OUTPUT_DIR, 'tag', 'tag_cloud.html'), 'w') as t_file:
            t_file.write(render_to('tag_cloud.html', tag_dict=tag_dict))

 def __remove_user(database):
     from logical.models import Credential
     from util import slugify
     credential = Credential()
     credential.database = database
     credential.user = 'u_{}'.format(database.name[:Credential.USER_MAXIMUM_LENGTH_NAME])
     credential.user = slugify(credential.user)
     try:
         credential.driver.remove_user(credential)
     except InvalidCredential:
         pass

def get_premiere_live(logo):
    #provider_id is hardcoded right now. 
    provider_id = '520142353f8adb4c90000008'
    live = dict([(util.slugify(json['time_mandante']['sigla'] + 'x' + json['time_visitante']['sigla']), {
                'name': json['time_mandante']['sigla'] + ' x ' + json['time_visitante']['sigla'],
                'logo': logo,
                'playable': True,
                'plot': json['campeonato'] + ': ' + json['time_mandante']['nome'] + ' x ' + json['time_visitante']['nome'] + ' (' + json['estadio'] + '). ' + json['data'],
                'id': json['id_midia'],
            }) for json in get_page(PREMIERE_LIVE_JSON % provider_id)['jogos']])
    return live

 def __init__(self, *arg, **kwargs):
   self.name = util.slugify(kwargs.pop('name', 'my-camera'))
   self.directory = kwargs.pop('directory', path.dirname(path.realpath(__file__)))
   self.width = kwargs.pop('width', 640)
   self.height = kwargs.pop('height', 480)
   self.rotation = kwargs.pop('rotation', 0)
   self.init_camera()
   if self.is_working():
     util.print_out('CAMERA LOADED', self.full_name())
   else:
     util.print_out('CAMERA FAILD', self.full_name())