{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"get_view_file","parameters":"(handler, params={})","argument_list":"","return_statement":"return {'file': 'notfound.html', 'dirs': template_dirs}","docstring":"Looks for presence of template files with priority given to \n     HTTP method (verb) and role.\n    Full filenames are <handler>.<role>.<verb>.<ext> where\n     <handler> = lower-case handler name\n     <role> = role of current user\n     <verb> = HTTP verb, e.g. GET or POST\n     <ext> = html, xml, etc.\n    Only <handler> and <ext> are required.\n    Properties 'module_name' and 'handler_name' can be passed in \n     params to override the current module\/handler name.\n     \n    Returns:\n      Tuple with first element = template file name and\n      second element = template directory path tuple","docstring_summary":"Looks for presence of template files with priority given to \n     HTTP method (verb) and role.\n    Full filenames are <handler>.<role>.<verb>.<ext> where\n     <handler> = lower-case handler name\n     <role> = role of current user\n     <verb> = HTTP verb, e.g. GET or POST\n     <ext> = html, xml, etc.\n    Only <handler> and <ext> are required.\n    Properties 'module_name' and 'handler_name' can be passed in \n     params to override the current module\/handler name.\n     \n    Returns:\n      Tuple with first element = template file name and\n      second element = template directory path tuple","docstring_tokens":["Looks","for","presence","of","template","files","with","priority","given","to","HTTP","method","(","verb",")","and","role",".","Full","filenames","are","<handler",">",".","<role",">",".","<verb",">",".","<ext",">","where","<handler",">","=","lower","-","case","handler","name","<role",">","=","role","of","current","user","<verb",">","=","HTTP","verb","e",".","g",".","GET","or","POST","<ext",">","=","html","xml","etc",".","Only","<handler",">","and","<ext",">","are","required",".","Properties","module_name","and","handler_name","can","be","passed","in","params","to","override","the","current","module","\/","handler","name",".","Returns",":","Tuple","with","first","element","=","template","file","name","and","second","element","=","template","directory","path","tuple"],"function":"def get_view_file(handler, params={}):\n    \"\"\"\n    Looks for presence of template files with priority given to \n     HTTP method (verb) and role.\n    Full filenames are <handler>.<role>.<verb>.<ext> where\n     <handler> = lower-case handler name\n     <role> = role of current user\n     <verb> = HTTP verb, e.g. GET or POST\n     <ext> = html, xml, etc.\n    Only <handler> and <ext> are required.\n    Properties 'module_name' and 'handler_name' can be passed in \n     params to override the current module\/handler name.\n     \n    Returns:\n      Tuple with first element = template file name and\n      second element = template directory path tuple\n    \"\"\"\n    if 'ext' in params:\n        desired_ext = params['ext']\n    else:\n        desired_ext = 'html'\n\n    verb = handler.request.method.lower()\n    app_name = ''\n    module_name = None\n    handler_name = None\n    cls = handler.__class__\n    if (cls.__module__.startswith('handlers.')\n        and cls.__name__.endswith('Handler')):\n        handler_path = cls.__module__.split('.')\n        if len(handler_path) == 3:\n            app_name = to_filename(handler_path[1])\n        module_name = to_filename(handler_path[-1])\n        handler_name = to_filename(cls.__name__.partition('Handler')[0])\n\n    if 'app_name' in params:\n        app_name = params['app_name']\n    if 'module_name' in params:\n        module_name = params['module_name']\n    if 'handler_name' in params:\n        handler_name = params['handler_name']\n\n    # Get template directory hierarchy -- Needed if we inherit from templates\n    # in directories above us (due to sharing with other templates).\n    themes = config.BLOG['theme']\n    if isinstance(themes, basestring):\n      themes = [themes]\n    template_dirs = []\n    views_dir = os.path.join(config.APP_ROOT_DIR, 'views')\n    for theme in themes:\n      root_folder = os.path.join(views_dir, theme)\n      if module_name:\n          template_dirs += (os.path.join(root_folder, app_name, module_name),)\n      if app_name:\n          template_dirs += (os.path.join(root_folder, app_name),)\n      template_dirs += (root_folder,)\n        \n    # Now check possible extensions for the given template file.\n    if module_name and handler_name:\n        entries = templates.get(app_name, {}).get(module_name, {})\n        possible_roles = []\n        if users.is_current_user_admin():\n            possible_roles.append('.admin.')\n        if users.get_current_user():\n            possible_roles.append('.user.')\n        possible_roles.append('.')\n        for role in possible_roles:\n            filename = ''.join([handler_name, role, verb, '.', desired_ext])\n            if filename in entries:\n                return {'file': filename, 'dirs': template_dirs}\n        for role in possible_roles:\n            filename = ''.join([handler_name, role, desired_ext])\n            if filename in entries:\n                return {'file': filename, 'dirs': template_dirs}\n    return {'file': 'notfound.html', 'dirs': template_dirs}","function_tokens":["def","get_view_file","(","handler",",","params","=","{","}",")",":","if","'ext'","in","params",":","desired_ext","=","params","[","'ext'","]","else",":","desired_ext","=","'html'","verb","=","handler",".","request",".","method",".","lower","(",")","app_name","=","''","module_name","=","None","handler_name","=","None","cls","=","handler",".","__class__","if","(","cls",".","__module__",".","startswith","(","'handlers.'",")","and","cls",".","__name__",".","endswith","(","'Handler'",")",")",":","handler_path","=","cls",".","__module__",".","split","(","'.'",")","if","len","(","handler_path",")","==","3",":","app_name","=","to_filename","(","handler_path","[","1","]",")","module_name","=","to_filename","(","handler_path","[","-","1","]",")","handler_name","=","to_filename","(","cls",".","__name__",".","partition","(","'Handler'",")","[","0","]",")","if","'app_name'","in","params",":","app_name","=","params","[","'app_name'","]","if","'module_name'","in","params",":","module_name","=","params","[","'module_name'","]","if","'handler_name'","in","params",":","handler_name","=","params","[","'handler_name'","]","# Get template directory hierarchy -- Needed if we inherit from templates","# in directories above us (due to sharing with other templates).","themes","=","config",".","BLOG","[","'theme'","]","if","isinstance","(","themes",",","basestring",")",":","themes","=","[","themes","]","template_dirs","=","[","]","views_dir","=","os",".","path",".","join","(","config",".","APP_ROOT_DIR",",","'views'",")","for","theme","in","themes",":","root_folder","=","os",".","path",".","join","(","views_dir",",","theme",")","if","module_name",":","template_dirs","+=","(","os",".","path",".","join","(","root_folder",",","app_name",",","module_name",")",",",")","if","app_name",":","template_dirs","+=","(","os",".","path",".","join","(","root_folder",",","app_name",")",",",")","template_dirs","+=","(","root_folder",",",")","# Now check possible extensions for the given template file.","if","module_name","and","handler_name",":","entries","=","templates",".","get","(","app_name",",","{","}",")",".","get","(","module_name",",","{","}",")","possible_roles","=","[","]","if","users",".","is_current_user_admin","(",")",":","possible_roles",".","append","(","'.admin.'",")","if","users",".","get_current_user","(",")",":","possible_roles",".","append","(","'.user.'",")","possible_roles",".","append","(","'.'",")","for","role","in","possible_roles",":","filename","=","''",".","join","(","[","handler_name",",","role",",","verb",",","'.'",",","desired_ext","]",")","if","filename","in","entries",":","return","{","'file'",":","filename",",","'dirs'",":","template_dirs","}","for","role","in","possible_roles",":","filename","=","''",".","join","(","[","handler_name",",","role",",","desired_ext","]",")","if","filename","in","entries",":","return","{","'file'",":","filename",",","'dirs'",":","template_dirs","}","return","{","'file'",":","'notfound.html'",",","'dirs'",":","template_dirs","}"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L77-L151"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"ViewPage.__init__","parameters":"(self, cache_time=None)","argument_list":"","return_statement":"","docstring":"Each ViewPage has a variable cache timeout","docstring_summary":"Each ViewPage has a variable cache timeout","docstring_tokens":["Each","ViewPage","has","a","variable","cache","timeout"],"function":"def __init__(self, cache_time=None):\n        \"\"\"Each ViewPage has a variable cache timeout\"\"\"\n        if cache_time == None:\n            self.cache_time = config.BLOG['cache_time']\n        else:\n            self.cache_time = cache_time","function_tokens":["def","__init__","(","self",",","cache_time","=","None",")",":","if","cache_time","==","None",":","self",".","cache_time","=","config",".","BLOG","[","'cache_time'","]","else",":","self",".","cache_time","=","cache_time"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L154-L159"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"ViewPage.full_render","parameters":"(self, handler, template_info, more_params)","argument_list":"","return_statement":"return template.render(template_info['file'], template_params,\n                               debug=config.DEBUG, \n                               template_dirs=template_info['dirs'])","docstring":"Render a dynamic page from scatch.","docstring_summary":"Render a dynamic page from scatch.","docstring_tokens":["Render","a","dynamic","page","from","scatch","."],"function":"def full_render(self, handler, template_info, more_params):\n        \"\"\"Render a dynamic page from scatch.\"\"\"\n        logging.debug(\"Doing full render using template_file: %s\", template_info['file'])\n        url = handler.request.uri\n        scheme, netloc, path, query, fragment = urlparse.urlsplit(url)\n\n        global NUM_FULL_RENDERS\n        if not path in NUM_FULL_RENDERS:\n            NUM_FULL_RENDERS[path] = 0\n        NUM_FULL_RENDERS[path] += 1     # This lets us see % of cached views\n                                        # in \/admin\/timings (see timings.py)\n        tags = Tag.list()\n\n        # Define some parameters it'd be nice to have in views by default.\n        template_params = {\n            \"current_url\": url,\n            \"bloog_version\": config.BLOG['bloog_version'],\n            \"user\": users.get_current_user(),\n            \"user_is_admin\": users.is_current_user_admin(),\n            \"login_url\": users.create_login_url(handler.request.uri),\n            \"logout_url\": users.create_logout_url(handler.request.uri),\n            \"blog\": config.BLOG,\n            \"blog_tags\": tags\n        }\n        template_params.update(config.PAGE)\n        template_params.update(more_params)\n        return template.render(template_info['file'], template_params,\n                               debug=config.DEBUG, \n                               template_dirs=template_info['dirs'])","function_tokens":["def","full_render","(","self",",","handler",",","template_info",",","more_params",")",":","logging",".","debug","(","\"Doing full render using template_file: %s\"",",","template_info","[","'file'","]",")","url","=","handler",".","request",".","uri","scheme",",","netloc",",","path",",","query",",","fragment","=","urlparse",".","urlsplit","(","url",")","global","NUM_FULL_RENDERS","if","not","path","in","NUM_FULL_RENDERS",":","NUM_FULL_RENDERS","[","path","]","=","0","NUM_FULL_RENDERS","[","path","]","+=","1","# This lets us see % of cached views","# in \/admin\/timings (see timings.py)","tags","=","Tag",".","list","(",")","# Define some parameters it'd be nice to have in views by default.","template_params","=","{","\"current_url\"",":","url",",","\"bloog_version\"",":","config",".","BLOG","[","'bloog_version'","]",",","\"user\"",":","users",".","get_current_user","(",")",",","\"user_is_admin\"",":","users",".","is_current_user_admin","(",")",",","\"login_url\"",":","users",".","create_login_url","(","handler",".","request",".","uri",")",",","\"logout_url\"",":","users",".","create_logout_url","(","handler",".","request",".","uri",")",",","\"blog\"",":","config",".","BLOG",",","\"blog_tags\"",":","tags","}","template_params",".","update","(","config",".","PAGE",")","template_params",".","update","(","more_params",")","return","template",".","render","(","template_info","[","'file'","]",",","template_params",",","debug","=","config",".","DEBUG",",","template_dirs","=","template_info","[","'dirs'","]",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L161-L189"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"ViewPage.render_or_get_cache","parameters":"(self, handler, template_info, template_params={})","argument_list":"","return_statement":"return output","docstring":"Checks if there's a non-stale cached version of this view, \n           and if so, return it.","docstring_summary":"Checks if there's a non-stale cached version of this view, \n           and if so, return it.","docstring_tokens":["Checks","if","there","s","a","non","-","stale","cached","version","of","this","view","and","if","so","return","it","."],"function":"def render_or_get_cache(self, handler, template_info, template_params={}):\n        \"\"\"Checks if there's a non-stale cached version of this view, \n           and if so, return it.\"\"\"\n        user = users.get_current_user()\n        key = handler.request.url\n        if self.cache_time and not user:\n            # See if there's a cache within time.\n            # The cache key suggests a problem with the url <-> function \n            #  mapping, because a significant advantage of RESTful design \n            #  is that a distinct url gets you a distinct, cacheable \n            #  resource.  If we have to include states like \"user?\" and \n            #  \"admin?\", then it suggests these flags should be in url.               \n            # TODO - Think about the above with respect to caching.\n            try:\n                data = memcache.get(key)\n            except ValueError:\n                data = None\n            if data is not None:\n                return data\n\n        output = self.full_render(handler, template_info, template_params)\n        if self.cache_time and not user:\n            memcache.add(key, output, self.cache_time)\n        return output","function_tokens":["def","render_or_get_cache","(","self",",","handler",",","template_info",",","template_params","=","{","}",")",":","user","=","users",".","get_current_user","(",")","key","=","handler",".","request",".","url","if","self",".","cache_time","and","not","user",":","# See if there's a cache within time.","# The cache key suggests a problem with the url <-> function ","#  mapping, because a significant advantage of RESTful design ","#  is that a distinct url gets you a distinct, cacheable ","#  resource.  If we have to include states like \"user?\" and ","#  \"admin?\", then it suggests these flags should be in url.               ","# TODO - Think about the above with respect to caching.","try",":","data","=","memcache",".","get","(","key",")","except","ValueError",":","data","=","None","if","data","is","not","None",":","return","data","output","=","self",".","full_render","(","handler",",","template_info",",","template_params",")","if","self",".","cache_time","and","not","user",":","memcache",".","add","(","key",",","output",",","self",".","cache_time",")","return","output"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L191-L214"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"ViewPage.render","parameters":"(self, handler, params={})","argument_list":"","return_statement":"","docstring":"Can pass overriding parameters within dict.  These parameters can \n        include:\n            'ext': 'xml' (or any other format type)","docstring_summary":"Can pass overriding parameters within dict.  These parameters can \n        include:\n            'ext': 'xml' (or any other format type)","docstring_tokens":["Can","pass","overriding","parameters","within","dict",".","These","parameters","can","include",":","ext",":","xml","(","or","any","other","format","type",")"],"function":"def render(self, handler, params={}):\n        \"\"\"\n        Can pass overriding parameters within dict.  These parameters can \n        include:\n            'ext': 'xml' (or any other format type)\n        \"\"\"\n        template_info = get_view_file(handler, params)\n        logging.debug(\"Using template at %s\", template_info['file'])\n        output = self.render_or_get_cache(handler, template_info, params)\n        handler.response.out.write(output)","function_tokens":["def","render","(","self",",","handler",",","params","=","{","}",")",":","template_info","=","get_view_file","(","handler",",","params",")","logging",".","debug","(","\"Using template at %s\"",",","template_info","[","'file'","]",")","output","=","self",".","render_or_get_cache","(","handler",",","template_info",",","params",")","handler",".","response",".","out",".","write","(","output",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L216-L225"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"view.py","language":"python","identifier":"ViewPage.render_query","parameters":"(self, handler, model_name, query, params={},\n                     num_limit=config.PAGE['articles_per_page'],\n                     num_offset=0)","argument_list":"","return_statement":"","docstring":"Handles typical rendering of queries into datastore\n        with paging.","docstring_summary":"Handles typical rendering of queries into datastore\n        with paging.","docstring_tokens":["Handles","typical","rendering","of","queries","into","datastore","with","paging","."],"function":"def render_query(self, handler, model_name, query, params={},\n                     num_limit=config.PAGE['articles_per_page'],\n                     num_offset=0):\n        \"\"\"\n        Handles typical rendering of queries into datastore\n        with paging.\n        \"\"\"\n        limit = string.atoi(handler.request.get(\"limit\") or str(num_limit))\n        offset = string.atoi(handler.request.get(\"offset\") or str(num_offset))\n        # Trick is to ask for one more than you need to see if 'next' needed.\n        models = query.fetch(limit+1, offset)\n        render_params = {model_name: models, 'limit': limit}\n        if len(models) > limit:\n            render_params.update({ 'next_offset': str(offset+limit) })\n            models.pop()\n        if offset > 0:\n            render_params.update({ 'prev_offset': str(offset-limit) })\n        render_params.update(params)\n\n        self.render(handler, render_params)","function_tokens":["def","render_query","(","self",",","handler",",","model_name",",","query",",","params","=","{","}",",","num_limit","=","config",".","PAGE","[","'articles_per_page'","]",",","num_offset","=","0",")",":","limit","=","string",".","atoi","(","handler",".","request",".","get","(","\"limit\"",")","or","str","(","num_limit",")",")","offset","=","string",".","atoi","(","handler",".","request",".","get","(","\"offset\"",")","or","str","(","num_offset",")",")","# Trick is to ask for one more than you need to see if 'next' needed.","models","=","query",".","fetch","(","limit","+","1",",","offset",")","render_params","=","{","model_name",":","models",",","'limit'",":","limit","}","if","len","(","models",")",">","limit",":","render_params",".","update","(","{","'next_offset'",":","str","(","offset","+","limit",")","}",")","models",".","pop","(",")","if","offset",">","0",":","render_params",".","update","(","{","'prev_offset'",":","str","(","offset","-","limit",")","}",")","render_params",".","update","(","params",")","self",".","render","(","handler",",","render_params",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/view.py#L227-L246"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/authorized.py","language":"python","identifier":"role","parameters":"(role)","argument_list":"","return_statement":"return wrapper","docstring":"A decorator to enforce user roles, currently 'user' (logged in) \n    and 'admin'.\n\n    To use it, decorate your handler methods like this:\n\n    import authorized\n    @authorized.role(\"admin\")\n    def get(self):\n      user = users.GetCurrentUser(self)\n      self.response.out.write('Hello, ' + user.nickname())\n\n    If this decorator is applied to a GET handler, we check if the \n    user is logged in and redirect her to the create_login_url() if not.\n\n    For HTTP verbs other than GET, we cannot do redirects to the login \n    url because the return redirects are done as GETs (not the original \n    HTTP verb for the handler).  So if the user is not logged in, we \n    return an error.","docstring_summary":"A decorator to enforce user roles, currently 'user' (logged in) \n    and 'admin'.","docstring_tokens":["A","decorator","to","enforce","user","roles","currently","user","(","logged","in",")","and","admin","."],"function":"def role(role):\n    \"\"\"\n    A decorator to enforce user roles, currently 'user' (logged in) \n    and 'admin'.\n\n    To use it, decorate your handler methods like this:\n\n    import authorized\n    @authorized.role(\"admin\")\n    def get(self):\n      user = users.GetCurrentUser(self)\n      self.response.out.write('Hello, ' + user.nickname())\n\n    If this decorator is applied to a GET handler, we check if the \n    user is logged in and redirect her to the create_login_url() if not.\n\n    For HTTP verbs other than GET, we cannot do redirects to the login \n    url because the return redirects are done as GETs (not the original \n    HTTP verb for the handler).  So if the user is not logged in, we \n    return an error.\n    \"\"\"\n    def wrapper(handler_method):\n        def check_login(self, *args, **kwargs):\n            user = users.get_current_user()\n            if not user:\n                if self.request.method != 'GET':\n                    logging.debug(\"Not user - aborting\")\n                    self.error(403)\n                else:\n                    logging.debug(\"User not logged in -- force login\")\n                    self.redirect(users.create_login_url(self.request.uri))\n            elif role == \"user\" or (role == \"admin\" and     \n                                    users.is_current_user_admin()):\n                logging.debug(\"Role is %s so will allow handler\", role)\n                handler_method(self, *args, **kwargs)\n            else:\n                if self.request.method == 'GET':\n                    logging.debug(\"Unknown role (%s) on GET\", role)\n                    self.redirect(\"\/403.html\")\n                else:\n                    logging.debug(\"Unknown role: %s\", role)\n                    self.error(403) # User didn't meet role.  \n                                    # TODO: Give better feedback\/status code.\n        return check_login\n    return wrapper","function_tokens":["def","role","(","role",")",":","def","wrapper","(","handler_method",")",":","def","check_login","(","self",",","*","args",",","*","*","kwargs",")",":","user","=","users",".","get_current_user","(",")","if","not","user",":","if","self",".","request",".","method","!=","'GET'",":","logging",".","debug","(","\"Not user - aborting\"",")","self",".","error","(","403",")","else",":","logging",".","debug","(","\"User not logged in -- force login\"",")","self",".","redirect","(","users",".","create_login_url","(","self",".","request",".","uri",")",")","elif","role","==","\"user\"","or","(","role","==","\"admin\"","and","users",".","is_current_user_admin","(",")",")",":","logging",".","debug","(","\"Role is %s so will allow handler\"",",","role",")","handler_method","(","self",",","*","args",",","*","*","kwargs",")","else",":","if","self",".","request",".","method","==","'GET'",":","logging",".","debug","(","\"Unknown role (%s) on GET\"",",","role",")","self",".","redirect","(","\"\/403.html\"",")","else",":","logging",".","debug","(","\"Unknown role: %s\"",",","role",")","self",".","error","(","403",")","# User didn't meet role.  ","# TODO: Give better feedback\/status code.","return","check_login","return","wrapper"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/authorized.py#L35-L79"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"render","parameters":"(template_path, template_dict, debug=False, template_dirs=())","argument_list":"","return_statement":"return t.render(Context(template_dict))","docstring":"Renders the template at the given path with the given dict of values.\n\n  Example usage:\n    render(\"templates\/index.html\", {\"name\": \"Bret\", \"values\": [1, 2, 3]})\n\n  Args:\n    template_path: path to a Django template\n    template_dict: dictionary of values to apply to the template","docstring_summary":"Renders the template at the given path with the given dict of values.","docstring_tokens":["Renders","the","template","at","the","given","path","with","the","given","dict","of","values","."],"function":"def render(template_path, template_dict, debug=False, template_dirs=()):\n  \"\"\"Renders the template at the given path with the given dict of values.\n\n  Example usage:\n    render(\"templates\/index.html\", {\"name\": \"Bret\", \"values\": [1, 2, 3]})\n\n  Args:\n    template_path: path to a Django template\n    template_dict: dictionary of values to apply to the template\n  \"\"\"\n  t = load(template_path, debug, template_dirs)\n  return t.render(Context(template_dict))","function_tokens":["def","render","(","template_path",",","template_dict",",","debug","=","False",",","template_dirs","=","(",")",")",":","t","=","load","(","template_path",",","debug",",","template_dirs",")","return","t",".","render","(","Context","(","template_dict",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L71-L82"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"load","parameters":"(path, debug=False, template_dirs=())","argument_list":"","return_statement":"return template","docstring":"Loads the Django template from the given path.\n\n  It is better to use this function than to construct a Template using the\n  class below because Django requires you to load the template with a method\n  if you want imports and extends to work in the template.","docstring_summary":"Loads the Django template from the given path.","docstring_tokens":["Loads","the","Django","template","from","the","given","path","."],"function":"def load(path, debug=False, template_dirs=()):\n  \"\"\"Loads the Django template from the given path.\n\n  It is better to use this function than to construct a Template using the\n  class below because Django requires you to load the template with a method\n  if you want imports and extends to work in the template.\n  \"\"\"\n  abspath = os.path.abspath(path)\n\n  if not debug:\n    template = template_cache.get(abspath, None)\n  else:\n    template = None\n\n  if not template:\n    directory, file_name = os.path.split(abspath)\n    if directory:\n      template_dirs = [directory] + template_dirs\n    new_settings = {\n        'TEMPLATE_DIRS': template_dirs,\n        'TEMPLATE_DEBUG': debug,\n        'DEBUG': debug,\n    }\n    old_settings = _swap_settings(new_settings)\n    try:\n      template = django.template.loader.get_template(file_name)\n    finally:\n      _swap_settings(old_settings)\n\n    if not debug:\n      template_cache[abspath] = template\n\n    def wrap_render(context, orig_render=template.render):\n      URLNode = django.template.defaulttags.URLNode\n      save_urlnode_render = URLNode.render\n      old_settings = _swap_settings(new_settings)\n      try:\n        URLNode.render = _urlnode_render_replacement\n        return orig_render(context)\n      finally:\n        _swap_settings(old_settings)\n        URLNode.render = save_urlnode_render\n\n    template.render = wrap_render\n\n  return template","function_tokens":["def","load","(","path",",","debug","=","False",",","template_dirs","=","(",")",")",":","abspath","=","os",".","path",".","abspath","(","path",")","if","not","debug",":","template","=","template_cache",".","get","(","abspath",",","None",")","else",":","template","=","None","if","not","template",":","directory",",","file_name","=","os",".","path",".","split","(","abspath",")","if","directory",":","template_dirs","=","[","directory","]","+","template_dirs","new_settings","=","{","'TEMPLATE_DIRS'",":","template_dirs",",","'TEMPLATE_DEBUG'",":","debug",",","'DEBUG'",":","debug",",","}","old_settings","=","_swap_settings","(","new_settings",")","try",":","template","=","django",".","template",".","loader",".","get_template","(","file_name",")","finally",":","_swap_settings","(","old_settings",")","if","not","debug",":","template_cache","[","abspath","]","=","template","def","wrap_render","(","context",",","orig_render","=","template",".","render",")",":","URLNode","=","django",".","template",".","defaulttags",".","URLNode","save_urlnode_render","=","URLNode",".","render","old_settings","=","_swap_settings","(","new_settings",")","try",":","URLNode",".","render","=","_urlnode_render_replacement","return","orig_render","(","context",")","finally",":","_swap_settings","(","old_settings",")","URLNode",".","render","=","save_urlnode_render","template",".","render","=","wrap_render","return","template"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L86-L131"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"_swap_settings","parameters":"(new)","argument_list":"","return_statement":"return old","docstring":"Swap in selected Django settings, returning old settings.\n\n  Example:\n    save = _swap_settings({'X': 1, 'Y': 2})\n    try:\n      ...new settings for X and Y are in effect here...\n    finally:\n      _swap_settings(save)\n\n  Args:\n    new: A dict containing settings to change; the keys should\n      be setting names and the values settings values.\n\n  Returns:\n    Another dict structured the same was as the argument containing\n    the original settings.  Original settings that were not set at all\n    are returned as None, and will be restored as None by the\n    'finally' clause in the example above.  This shouldn't matter; we\n    can't delete settings that are given as None, since None is also a\n    legitimate value for some settings.  Creating a separate flag value\n    for 'unset' settings seems overkill as there is no known use case.","docstring_summary":"Swap in selected Django settings, returning old settings.","docstring_tokens":["Swap","in","selected","Django","settings","returning","old","settings","."],"function":"def _swap_settings(new):\n  \"\"\"Swap in selected Django settings, returning old settings.\n\n  Example:\n    save = _swap_settings({'X': 1, 'Y': 2})\n    try:\n      ...new settings for X and Y are in effect here...\n    finally:\n      _swap_settings(save)\n\n  Args:\n    new: A dict containing settings to change; the keys should\n      be setting names and the values settings values.\n\n  Returns:\n    Another dict structured the same was as the argument containing\n    the original settings.  Original settings that were not set at all\n    are returned as None, and will be restored as None by the\n    'finally' clause in the example above.  This shouldn't matter; we\n    can't delete settings that are given as None, since None is also a\n    legitimate value for some settings.  Creating a separate flag value\n    for 'unset' settings seems overkill as there is no known use case.\n  \"\"\"\n  settings = django.conf.settings\n  old = {}\n  for key, value in new.iteritems():\n    old[key] = getattr(settings, key, None)\n    setattr(settings, key, value)\n  return old","function_tokens":["def","_swap_settings","(","new",")",":","settings","=","django",".","conf",".","settings","old","=","{","}","for","key",",","value","in","new",".","iteritems","(",")",":","old","[","key","]","=","getattr","(","settings",",","key",",","None",")","setattr","(","settings",",","key",",","value",")","return","old"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L134-L162"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"create_template_register","parameters":"()","argument_list":"","return_statement":"return django.template.Library()","docstring":"Used to extend the Django template library with custom filters and tags.\n\n  To extend the template library with a custom filter module, create a Python\n  module, and create a module-level variable named \"register\", and register\n  all custom filters to it as described at\n  http:\/\/www.djangoproject.com\/documentation\/templates_python\/\n    #extending-the-template-system:\n\n    templatefilters.py\n    ==================\n    register = webapp.template.create_template_register()\n\n    def cut(value, arg):\n      return value.replace(arg, '')\n    register.filter(cut)\n\n  Then, register the custom template module with the register_template_module\n  function below in your application module:\n\n    myapp.py\n    ========\n    webapp.template.register_template_module('templatefilters')","docstring_summary":"Used to extend the Django template library with custom filters and tags.","docstring_tokens":["Used","to","extend","the","Django","template","library","with","custom","filters","and","tags","."],"function":"def create_template_register():\n  \"\"\"Used to extend the Django template library with custom filters and tags.\n\n  To extend the template library with a custom filter module, create a Python\n  module, and create a module-level variable named \"register\", and register\n  all custom filters to it as described at\n  http:\/\/www.djangoproject.com\/documentation\/templates_python\/\n    #extending-the-template-system:\n\n    templatefilters.py\n    ==================\n    register = webapp.template.create_template_register()\n\n    def cut(value, arg):\n      return value.replace(arg, '')\n    register.filter(cut)\n\n  Then, register the custom template module with the register_template_module\n  function below in your application module:\n\n    myapp.py\n    ========\n    webapp.template.register_template_module('templatefilters')\n  \"\"\"\n  return django.template.Library()","function_tokens":["def","create_template_register","(",")",":","return","django",".","template",".","Library","(",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L165-L189"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"register_template_library","parameters":"(package_name)","argument_list":"","return_statement":"","docstring":"Registers a template extension module to make it usable in templates.\n\n  See the documentation for create_template_register for more information.","docstring_summary":"Registers a template extension module to make it usable in templates.","docstring_tokens":["Registers","a","template","extension","module","to","make","it","usable","in","templates","."],"function":"def register_template_library(package_name):\n  \"\"\"Registers a template extension module to make it usable in templates.\n\n  See the documentation for create_template_register for more information.\"\"\"\n  if not django.template.libraries.get(package_name, None):\n    django.template.add_to_builtins(package_name)","function_tokens":["def","register_template_library","(","package_name",")",":","if","not","django",".","template",".","libraries",".","get","(","package_name",",","None",")",":","django",".","template",".","add_to_builtins","(","package_name",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L192-L197"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/template.py","language":"python","identifier":"_urlnode_render_replacement","parameters":"(self, context)","argument_list":"","return_statement":"","docstring":"Replacement for django's {% url %} block.\n\n  This version uses WSGIApplication's url mapping to create urls.\n\n  Examples:\n\n  <a href=\"{% url MyPageHandler \"overview\" %}\">\n  {% url MyPageHandler implicit_args=False %}\n  {% url MyPageHandler \"calendar\" %}\n  {% url MyPageHandler \"jsmith\",\"calendar\" %}","docstring_summary":"Replacement for django's {% url %} block.","docstring_tokens":["Replacement","for","django","s","{","%","url","%","}","block","."],"function":"def _urlnode_render_replacement(self, context):\n  \"\"\"Replacement for django's {% url %} block.\n\n  This version uses WSGIApplication's url mapping to create urls.\n\n  Examples:\n\n  <a href=\"{% url MyPageHandler \"overview\" %}\">\n  {% url MyPageHandler implicit_args=False %}\n  {% url MyPageHandler \"calendar\" %}\n  {% url MyPageHandler \"jsmith\",\"calendar\" %}\n  \"\"\"\n  args = [arg.resolve(context) for arg in self.args]\n  try:\n    app = webapp.WSGIApplication.active_instance\n    handler = app.get_registered_handler_by_name(self.view_name)\n    return handler.get_url(implicit_args=True, *args)\n  except webapp.NoUrlFoundError:\n    return ''","function_tokens":["def","_urlnode_render_replacement","(","self",",","context",")",":","args","=","[","arg",".","resolve","(","context",")","for","arg","in","self",".","args","]","try",":","app","=","webapp",".","WSGIApplication",".","active_instance","handler","=","app",".","get_registered_handler_by_name","(","self",".","view_name",")","return","handler",".","get_url","(","implicit_args","=","True",",","*","args",")","except","webapp",".","NoUrlFoundError",":","return","''"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/template.py#L204-L222"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/codehighlighter.py","language":"python","identifier":"process_html","parameters":"(html)","argument_list":"","return_statement":"return clean_html.decode('utf-8'), list_language_files","docstring":"Processes HTML for embedded code using SyntaxHighlighter\n    \n    Determines languages used by checking class attribute of pre tags\n    with name=\"code\".\n\n    Args:\n      html: HTML to be processed for embedded code\n\n    Returns:\n      The modified html and a list of strings giving the embedded\n      code languages.","docstring_summary":"Processes HTML for embedded code using SyntaxHighlighter\n    \n    Determines languages used by checking class attribute of pre tags\n    with name=\"code\".","docstring_tokens":["Processes","HTML","for","embedded","code","using","SyntaxHighlighter","Determines","languages","used","by","checking","class","attribute","of","pre","tags","with","name","=","code","."],"function":"def process_html(html):\n    \"\"\"Processes HTML for embedded code using SyntaxHighlighter\n    \n    Determines languages used by checking class attribute of pre tags\n    with name=\"code\".\n\n    Args:\n      html: HTML to be processed for embedded code\n\n    Returns:\n      The modified html and a list of strings giving the embedded\n      code languages.\n    \"\"\"\n    code_tag = re.compile('\\s*<pre name=\"code\" class=\"([^\"]+)\">', \n                          re.MULTILINE)\n    languages = set([])\n    soup = BeautifulSoup(html)\n    clean_html = ''\n    for section in soup.contents:\n        txt = str(section)\n        matchobj = re.match(code_tag, txt)\n        if matchobj:\n            languages.add(matchobj.group(1))\n            clean_html += re.sub(r'<br \/>', \"\\n\", txt)\n        else:\n            clean_html += txt\n            \n    # Map the language class names to the spelling for javascript files\n    list_language_files = [language_jsfiles[lang] for lang in list(languages)]\n    return clean_html.decode('utf-8'), list_language_files","function_tokens":["def","process_html","(","html",")",":","code_tag","=","re",".","compile","(","'\\s*<pre name=\"code\" class=\"([^\"]+)\">'",",","re",".","MULTILINE",")","languages","=","set","(","[","]",")","soup","=","BeautifulSoup","(","html",")","clean_html","=","''","for","section","in","soup",".","contents",":","txt","=","str","(","section",")","matchobj","=","re",".","match","(","code_tag",",","txt",")","if","matchobj",":","languages",".","add","(","matchobj",".","group","(","1",")",")","clean_html","+=","re",".","sub","(","r'<br \/>'",",","\"\\n\"",",","txt",")","else",":","clean_html","+=","txt","# Map the language class names to the spelling for javascript files","list_language_files","=","[","language_jsfiles","[","lang","]","for","lang","in","list","(","languages",")","]","return","clean_html",".","decode","(","'utf-8'",")",",","list_language_files"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/codehighlighter.py#L40-L69"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/sanitizer.py","language":"python","identifier":"sanitize_html","parameters":"(html='<p>No comment<\/p>', encoding=None,\n                  allow_tags=[], allow_attributes=[],\n                  blacklist_tags=[], blacklist_attributes=[],\n                  trusted_source=False)","argument_list":"","return_statement":"return soup.renderContents().decode('utf-8')","docstring":"Parses HTML and tries to sanitize it using white list.\n    \n    This method is a mishmash of code from Django snippets\n    (http:\/\/www.djangosnippets.org\/snippets\/169) and the\n    HTML sanitization of Universal Feed Parser.  It explicitly\n    looks for valid hrefs to prevent scripts lurking in there.\n    Unfortunately, style, either as a tag or attribute, can\n    contain malicious script through executable CSS definitions.\n    So sanitized HTML cannot be colored or highlighted using styles.\n\n    Args:\n      html: HTML to be sanitized.\n      allow_tags: limit all tags to just this list\n      allow_attributes: limit all tags to just this list\n      allow_styling: should only be TRUE if you trust source\n\n    Returns:\n      Sanitized version of html\n\n    Raises:\n      DangerousHTMLError if the supplied HTML has dangerous elements.","docstring_summary":"Parses HTML and tries to sanitize it using white list.\n    \n    This method is a mishmash of code from Django snippets\n    (http:\/\/www.djangosnippets.org\/snippets\/169) and the\n    HTML sanitization of Universal Feed Parser.  It explicitly\n    looks for valid hrefs to prevent scripts lurking in there.\n    Unfortunately, style, either as a tag or attribute, can\n    contain malicious script through executable CSS definitions.\n    So sanitized HTML cannot be colored or highlighted using styles.","docstring_tokens":["Parses","HTML","and","tries","to","sanitize","it","using","white","list",".","This","method","is","a","mishmash","of","code","from","Django","snippets","(","http",":","\/\/","www",".","djangosnippets",".","org","\/","snippets","\/","169",")","and","the","HTML","sanitization","of","Universal","Feed","Parser",".","It","explicitly","looks","for","valid","hrefs","to","prevent","scripts","lurking","in","there",".","Unfortunately","style","either","as","a","tag","or","attribute","can","contain","malicious","script","through","executable","CSS","definitions",".","So","sanitized","HTML","cannot","be","colored","or","highlighted","using","styles","."],"function":"def sanitize_html(html='<p>No comment<\/p>', encoding=None,\n                  allow_tags=[], allow_attributes=[],\n                  blacklist_tags=[], blacklist_attributes=[],\n                  trusted_source=False):\n    \"\"\"Parses HTML and tries to sanitize it using white list.\n    \n    This method is a mishmash of code from Django snippets\n    (http:\/\/www.djangosnippets.org\/snippets\/169) and the\n    HTML sanitization of Universal Feed Parser.  It explicitly\n    looks for valid hrefs to prevent scripts lurking in there.\n    Unfortunately, style, either as a tag or attribute, can\n    contain malicious script through executable CSS definitions.\n    So sanitized HTML cannot be colored or highlighted using styles.\n\n    Args:\n      html: HTML to be sanitized.\n      allow_tags: limit all tags to just this list\n      allow_attributes: limit all tags to just this list\n      allow_styling: should only be TRUE if you trust source\n\n    Returns:\n      Sanitized version of html\n\n    Raises:\n      DangerousHTMLError if the supplied HTML has dangerous elements.\n    \"\"\"\n    if not allow_tags:\n        allow_tags = acceptable_tags\n    if not allow_attributes:\n        allow_attributes = acceptable_attributes\n    allow_tags = [tag for tag in allow_tags if tag not in blacklist_tags]\n    allow_attributes = [tag for tag in allow_attributes \n                        if tag not in blacklist_tags]\n    if trusted_source:\n        allow_attributes += attributes_for_trusted_source\n        allow_tags += tags_for_trusted_source\n\n    if isinstance(html, unicode) and not encoding:\n        logging.debug(\"Sanitizing unicode input.\")\n        soup = BeautifulSoup(html,  \n                            convertEntities=BeautifulSoup.XHTML_ENTITIES)\n    else:\n        if not encoding:\n            encoding = 'latin-1'\n        logging.debug(\"Sanitizing string input, assuming %s\", encoding)\n        soup = BeautifulSoup(html.decode(encoding, 'ignore'),\n                             convertEntities=BeautifulSoup.XHTML_ENTITIES)\n    for comment in soup.findAll(\n                    text = lambda text: isinstance(text, Comment)):\n        comment.extract()\n    for tag in soup.findAll(True):\n        if tag.name not in allow_tags:\n            tag.hidden = True\n            if tag.name in danger_elements:\n                raise DangerousHTMLError(html)\n        ok_attrs = []\n        for attr, val in tag.attrs:\n            if attr == 'href' and not href_matcher.match(val) and not trusted_source:\n                continue\n            if attr in allow_attributes:\n                if attr in js_possible_attributes:\n                    if javascript_matcher.match(val):\n                        raise DangerousHTMLError(html)\n                ok_attrs += [(attr, val)]\n        tag.attrs = ok_attrs\n    return soup.renderContents().decode('utf-8')","function_tokens":["def","sanitize_html","(","html","=","'<p>No comment<\/p>'",",","encoding","=","None",",","allow_tags","=","[","]",",","allow_attributes","=","[","]",",","blacklist_tags","=","[","]",",","blacklist_attributes","=","[","]",",","trusted_source","=","False",")",":","if","not","allow_tags",":","allow_tags","=","acceptable_tags","if","not","allow_attributes",":","allow_attributes","=","acceptable_attributes","allow_tags","=","[","tag","for","tag","in","allow_tags","if","tag","not","in","blacklist_tags","]","allow_attributes","=","[","tag","for","tag","in","allow_attributes","if","tag","not","in","blacklist_tags","]","if","trusted_source",":","allow_attributes","+=","attributes_for_trusted_source","allow_tags","+=","tags_for_trusted_source","if","isinstance","(","html",",","unicode",")","and","not","encoding",":","logging",".","debug","(","\"Sanitizing unicode input.\"",")","soup","=","BeautifulSoup","(","html",",","convertEntities","=","BeautifulSoup",".","XHTML_ENTITIES",")","else",":","if","not","encoding",":","encoding","=","'latin-1'","logging",".","debug","(","\"Sanitizing string input, assuming %s\"",",","encoding",")","soup","=","BeautifulSoup","(","html",".","decode","(","encoding",",","'ignore'",")",",","convertEntities","=","BeautifulSoup",".","XHTML_ENTITIES",")","for","comment","in","soup",".","findAll","(","text","=","lambda","text",":","isinstance","(","text",",","Comment",")",")",":","comment",".","extract","(",")","for","tag","in","soup",".","findAll","(","True",")",":","if","tag",".","name","not","in","allow_tags",":","tag",".","hidden","=","True","if","tag",".","name","in","danger_elements",":","raise","DangerousHTMLError","(","html",")","ok_attrs","=","[","]","for","attr",",","val","in","tag",".","attrs",":","if","attr","==","'href'","and","not","href_matcher",".","match","(","val",")","and","not","trusted_source",":","continue","if","attr","in","allow_attributes",":","if","attr","in","js_possible_attributes",":","if","javascript_matcher",".","match","(","val",")",":","raise","DangerousHTMLError","(","html",")","ok_attrs","+=","[","(","attr",",","val",")","]","tag",".","attrs","=","ok_attrs","return","soup",".","renderContents","(",")",".","decode","(","'utf-8'",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/sanitizer.py#L66-L131"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/sanitizer.py","language":"python","identifier":"chop_up","parameters":"(text, chop_size=5)","argument_list":"","return_statement":"return [text[i*chop_size:min(chars,(i+1)*chop_size)] \n            for i in xrange(0, blocks)]","docstring":"Returns a list of smaller chunks of text","docstring_summary":"Returns a list of smaller chunks of text","docstring_tokens":["Returns","a","list","of","smaller","chunks","of","text"],"function":"def chop_up(text, chop_size=5):\n    \"Returns a list of smaller chunks of text\"\n    chars = len(text)\n    blocks = chars \/ chop_size\n    if chars % chop_size:\n        blocks += 1\n    return [text[i*chop_size:min(chars,(i+1)*chop_size)] \n            for i in xrange(0, blocks)]","function_tokens":["def","chop_up","(","text",",","chop_size","=","5",")",":","chars","=","len","(","text",")","blocks","=","chars","\/","chop_size","if","chars","%","chop_size",":","blocks","+=","1","return","[","text","[","i","*","chop_size",":","min","(","chars",",","(","i","+","1",")","*","chop_size",")","]","for","i","in","xrange","(","0",",","blocks",")","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/sanitizer.py#L133-L140"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"isList","parameters":"(l)","argument_list":"","return_statement":"return hasattr(l, '__iter__') \\\n           or (type(l) in (types.ListType, types.TupleType))","docstring":"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is listlike.","docstring_summary":"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is listlike.","docstring_tokens":["Convenience","method","that","works","with","all","2",".","x","versions","of","Python","to","determine","whether","or","not","something","is","listlike","."],"function":"def isList(l):\n    \"\"\"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is listlike.\"\"\"\n    return hasattr(l, '__iter__') \\\n           or (type(l) in (types.ListType, types.TupleType))","function_tokens":["def","isList","(","l",")",":","return","hasattr","(","l",",","'__iter__'",")","or","(","type","(","l",")","in","(","types",".","ListType",",","types",".","TupleType",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L946-L950"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"isString","parameters":"(s)","argument_list":"","return_statement":"","docstring":"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is stringlike.","docstring_summary":"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is stringlike.","docstring_tokens":["Convenience","method","that","works","with","all","2",".","x","versions","of","Python","to","determine","whether","or","not","something","is","stringlike","."],"function":"def isString(s):\n    \"\"\"Convenience method that works with all 2.x versions of Python\n    to determine whether or not something is stringlike.\"\"\"\n    try:\n        return isinstance(s, unicode) or isinstance(s, basestring)\n    except NameError:\n        return isinstance(s, str)","function_tokens":["def","isString","(","s",")",":","try",":","return","isinstance","(","s",",","unicode",")","or","isinstance","(","s",",","basestring",")","except","NameError",":","return","isinstance","(","s",",","str",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L952-L958"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"buildTagMap","parameters":"(default, *args)","argument_list":"","return_statement":"return built","docstring":"Turns a list of maps, lists, or scalars into a single map.\n    Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and\n    NESTING_RESET_TAGS maps out of lists and partial maps.","docstring_summary":"Turns a list of maps, lists, or scalars into a single map.\n    Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and\n    NESTING_RESET_TAGS maps out of lists and partial maps.","docstring_tokens":["Turns","a","list","of","maps","lists","or","scalars","into","a","single","map",".","Used","to","build","the","SELF_CLOSING_TAGS","NESTABLE_TAGS","and","NESTING_RESET_TAGS","maps","out","of","lists","and","partial","maps","."],"function":"def buildTagMap(default, *args):\n    \"\"\"Turns a list of maps, lists, or scalars into a single map.\n    Used to build the SELF_CLOSING_TAGS, NESTABLE_TAGS, and\n    NESTING_RESET_TAGS maps out of lists and partial maps.\"\"\"\n    built = {}\n    for portion in args:\n        if hasattr(portion, 'items'):\n            #It's a map. Merge it.\n            for k,v in portion.items():\n                built[k] = v\n        elif isList(portion):\n            #It's a list. Map each item to the default.\n            for k in portion:\n                built[k] = default\n        else:\n            #It's a scalar. Map it to the default.\n            built[portion] = default\n    return built","function_tokens":["def","buildTagMap","(","default",",","*","args",")",":","built","=","{","}","for","portion","in","args",":","if","hasattr","(","portion",",","'items'",")",":","#It's a map. Merge it.","for","k",",","v","in","portion",".","items","(",")",":","built","[","k","]","=","v","elif","isList","(","portion",")",":","#It's a list. Map each item to the default.","for","k","in","portion",":","built","[","k","]","=","default","else",":","#It's a scalar. Map it to the default.","built","[","portion","]","=","default","return","built"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L960-L977"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.setup","parameters":"(self, parent=None, previous=None)","argument_list":"","return_statement":"","docstring":"Sets up the initial relations between this element and\n        other elements.","docstring_summary":"Sets up the initial relations between this element and\n        other elements.","docstring_tokens":["Sets","up","the","initial","relations","between","this","element","and","other","elements","."],"function":"def setup(self, parent=None, previous=None):\n        \"\"\"Sets up the initial relations between this element and\n        other elements.\"\"\"\n        self.parent = parent\n        self.previous = previous\n        self.next = None\n        self.previousSibling = None\n        self.nextSibling = None\n        if self.parent and self.parent.contents:\n            self.previousSibling = self.parent.contents[-1]\n            self.previousSibling.nextSibling = self","function_tokens":["def","setup","(","self",",","parent","=","None",",","previous","=","None",")",":","self",".","parent","=","parent","self",".","previous","=","previous","self",".","next","=","None","self",".","previousSibling","=","None","self",".","nextSibling","=","None","if","self",".","parent","and","self",".","parent",".","contents",":","self",".","previousSibling","=","self",".","parent",".","contents","[","-","1","]","self",".","previousSibling",".","nextSibling","=","self"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L113-L123"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.extract","parameters":"(self)","argument_list":"","return_statement":"return self","docstring":"Destructively rips this element out of the tree.","docstring_summary":"Destructively rips this element out of the tree.","docstring_tokens":["Destructively","rips","this","element","out","of","the","tree","."],"function":"def extract(self):\n        \"\"\"Destructively rips this element out of the tree.\"\"\"\n        if self.parent:\n            try:\n                self.parent.contents.remove(self)\n            except ValueError:\n                pass\n\n        #Find the two elements that would be next to each other if\n        #this element (and any children) hadn't been parsed. Connect\n        #the two.\n        lastChild = self._lastRecursiveChild()\n        nextElement = lastChild.next\n\n        if self.previous:\n            self.previous.next = nextElement\n        if nextElement:\n            nextElement.previous = self.previous\n        self.previous = None\n        lastChild.next = None\n\n        self.parent = None\n        if self.previousSibling:\n            self.previousSibling.nextSibling = self.nextSibling\n        if self.nextSibling:\n            self.nextSibling.previousSibling = self.previousSibling\n        self.previousSibling = self.nextSibling = None\n        return self","function_tokens":["def","extract","(","self",")",":","if","self",".","parent",":","try",":","self",".","parent",".","contents",".","remove","(","self",")","except","ValueError",":","pass","#Find the two elements that would be next to each other if","#this element (and any children) hadn't been parsed. Connect","#the two.","lastChild","=","self",".","_lastRecursiveChild","(",")","nextElement","=","lastChild",".","next","if","self",".","previous",":","self",".","previous",".","next","=","nextElement","if","nextElement",":","nextElement",".","previous","=","self",".","previous","self",".","previous","=","None","lastChild",".","next","=","None","self",".","parent","=","None","if","self",".","previousSibling",":","self",".","previousSibling",".","nextSibling","=","self",".","nextSibling","if","self",".","nextSibling",":","self",".","nextSibling",".","previousSibling","=","self",".","previousSibling","self",".","previousSibling","=","self",".","nextSibling","=","None","return","self"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L139-L166"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement._lastRecursiveChild","parameters":"(self)","argument_list":"","return_statement":"return lastChild","docstring":"Finds the last element beneath this object to be parsed.","docstring_summary":"Finds the last element beneath this object to be parsed.","docstring_tokens":["Finds","the","last","element","beneath","this","object","to","be","parsed","."],"function":"def _lastRecursiveChild(self):\n        \"Finds the last element beneath this object to be parsed.\"\n        lastChild = self\n        while hasattr(lastChild, 'contents') and lastChild.contents:\n            lastChild = lastChild.contents[-1]\n        return lastChild","function_tokens":["def","_lastRecursiveChild","(","self",")",":","lastChild","=","self","while","hasattr","(","lastChild",",","'contents'",")","and","lastChild",".","contents",":","lastChild","=","lastChild",".","contents","[","-","1","]","return","lastChild"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L168-L173"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.append","parameters":"(self, tag)","argument_list":"","return_statement":"","docstring":"Appends the given tag to the contents of this tag.","docstring_summary":"Appends the given tag to the contents of this tag.","docstring_tokens":["Appends","the","given","tag","to","the","contents","of","this","tag","."],"function":"def append(self, tag):\n        \"\"\"Appends the given tag to the contents of this tag.\"\"\"\n        self.insert(len(self.contents), tag)","function_tokens":["def","append","(","self",",","tag",")",":","self",".","insert","(","len","(","self",".","contents",")",",","tag",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L235-L237"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findNext","parameters":"(self, name=None, attrs={}, text=None, **kwargs)","argument_list":"","return_statement":"return self._findOne(self.findAllNext, name, attrs, text, **kwargs)","docstring":"Returns the first item that matches the given criteria and\n        appears after this Tag in the document.","docstring_summary":"Returns the first item that matches the given criteria and\n        appears after this Tag in the document.","docstring_tokens":["Returns","the","first","item","that","matches","the","given","criteria","and","appears","after","this","Tag","in","the","document","."],"function":"def findNext(self, name=None, attrs={}, text=None, **kwargs):\n        \"\"\"Returns the first item that matches the given criteria and\n        appears after this Tag in the document.\"\"\"\n        return self._findOne(self.findAllNext, name, attrs, text, **kwargs)","function_tokens":["def","findNext","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","*","*","kwargs",")",":","return","self",".","_findOne","(","self",".","findAllNext",",","name",",","attrs",",","text",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L239-L242"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findAllNext","parameters":"(self, name=None, attrs={}, text=None, limit=None,\n                    **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, text, limit, self.nextGenerator,\n                             **kwargs)","docstring":"Returns all items that match the given criteria and appear\n        after this Tag in the document.","docstring_summary":"Returns all items that match the given criteria and appear\n        after this Tag in the document.","docstring_tokens":["Returns","all","items","that","match","the","given","criteria","and","appear","after","this","Tag","in","the","document","."],"function":"def findAllNext(self, name=None, attrs={}, text=None, limit=None,\n                    **kwargs):\n        \"\"\"Returns all items that match the given criteria and appear\n        after this Tag in the document.\"\"\"\n        return self._findAll(name, attrs, text, limit, self.nextGenerator,\n                             **kwargs)","function_tokens":["def","findAllNext","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","limit","=","None",",","*","*","kwargs",")",":","return","self",".","_findAll","(","name",",","attrs",",","text",",","limit",",","self",".","nextGenerator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L244-L249"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findNextSibling","parameters":"(self, name=None, attrs={}, text=None, **kwargs)","argument_list":"","return_statement":"return self._findOne(self.findNextSiblings, name, attrs, text,\n                             **kwargs)","docstring":"Returns the closest sibling to this Tag that matches the\n        given criteria and appears after this Tag in the document.","docstring_summary":"Returns the closest sibling to this Tag that matches the\n        given criteria and appears after this Tag in the document.","docstring_tokens":["Returns","the","closest","sibling","to","this","Tag","that","matches","the","given","criteria","and","appears","after","this","Tag","in","the","document","."],"function":"def findNextSibling(self, name=None, attrs={}, text=None, **kwargs):\n        \"\"\"Returns the closest sibling to this Tag that matches the\n        given criteria and appears after this Tag in the document.\"\"\"\n        return self._findOne(self.findNextSiblings, name, attrs, text,\n                             **kwargs)","function_tokens":["def","findNextSibling","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","*","*","kwargs",")",":","return","self",".","_findOne","(","self",".","findNextSiblings",",","name",",","attrs",",","text",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L251-L255"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findNextSiblings","parameters":"(self, name=None, attrs={}, text=None, limit=None,\n                         **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, text, limit,\n                             self.nextSiblingGenerator, **kwargs)","docstring":"Returns the siblings of this Tag that match the given\n        criteria and appear after this Tag in the document.","docstring_summary":"Returns the siblings of this Tag that match the given\n        criteria and appear after this Tag in the document.","docstring_tokens":["Returns","the","siblings","of","this","Tag","that","match","the","given","criteria","and","appear","after","this","Tag","in","the","document","."],"function":"def findNextSiblings(self, name=None, attrs={}, text=None, limit=None,\n                         **kwargs):\n        \"\"\"Returns the siblings of this Tag that match the given\n        criteria and appear after this Tag in the document.\"\"\"\n        return self._findAll(name, attrs, text, limit,\n                             self.nextSiblingGenerator, **kwargs)","function_tokens":["def","findNextSiblings","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","limit","=","None",",","*","*","kwargs",")",":","return","self",".","_findAll","(","name",",","attrs",",","text",",","limit",",","self",".","nextSiblingGenerator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L257-L262"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findPrevious","parameters":"(self, name=None, attrs={}, text=None, **kwargs)","argument_list":"","return_statement":"return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)","docstring":"Returns the first item that matches the given criteria and\n        appears before this Tag in the document.","docstring_summary":"Returns the first item that matches the given criteria and\n        appears before this Tag in the document.","docstring_tokens":["Returns","the","first","item","that","matches","the","given","criteria","and","appears","before","this","Tag","in","the","document","."],"function":"def findPrevious(self, name=None, attrs={}, text=None, **kwargs):\n        \"\"\"Returns the first item that matches the given criteria and\n        appears before this Tag in the document.\"\"\"\n        return self._findOne(self.findAllPrevious, name, attrs, text, **kwargs)","function_tokens":["def","findPrevious","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","*","*","kwargs",")",":","return","self",".","_findOne","(","self",".","findAllPrevious",",","name",",","attrs",",","text",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L265-L268"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findAllPrevious","parameters":"(self, name=None, attrs={}, text=None, limit=None,\n                        **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, text, limit, self.previousGenerator,\n                           **kwargs)","docstring":"Returns all items that match the given criteria and appear\n        before this Tag in the document.","docstring_summary":"Returns all items that match the given criteria and appear\n        before this Tag in the document.","docstring_tokens":["Returns","all","items","that","match","the","given","criteria","and","appear","before","this","Tag","in","the","document","."],"function":"def findAllPrevious(self, name=None, attrs={}, text=None, limit=None,\n                        **kwargs):\n        \"\"\"Returns all items that match the given criteria and appear\n        before this Tag in the document.\"\"\"\n        return self._findAll(name, attrs, text, limit, self.previousGenerator,\n                           **kwargs)","function_tokens":["def","findAllPrevious","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","limit","=","None",",","*","*","kwargs",")",":","return","self",".","_findAll","(","name",",","attrs",",","text",",","limit",",","self",".","previousGenerator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L270-L275"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findPreviousSibling","parameters":"(self, name=None, attrs={}, text=None, **kwargs)","argument_list":"","return_statement":"return self._findOne(self.findPreviousSiblings, name, attrs, text,\n                             **kwargs)","docstring":"Returns the closest sibling to this Tag that matches the\n        given criteria and appears before this Tag in the document.","docstring_summary":"Returns the closest sibling to this Tag that matches the\n        given criteria and appears before this Tag in the document.","docstring_tokens":["Returns","the","closest","sibling","to","this","Tag","that","matches","the","given","criteria","and","appears","before","this","Tag","in","the","document","."],"function":"def findPreviousSibling(self, name=None, attrs={}, text=None, **kwargs):\n        \"\"\"Returns the closest sibling to this Tag that matches the\n        given criteria and appears before this Tag in the document.\"\"\"\n        return self._findOne(self.findPreviousSiblings, name, attrs, text,\n                             **kwargs)","function_tokens":["def","findPreviousSibling","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","*","*","kwargs",")",":","return","self",".","_findOne","(","self",".","findPreviousSiblings",",","name",",","attrs",",","text",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L278-L282"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findPreviousSiblings","parameters":"(self, name=None, attrs={}, text=None,\n                             limit=None, **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, text, limit,\n                             self.previousSiblingGenerator, **kwargs)","docstring":"Returns the siblings of this Tag that match the given\n        criteria and appear before this Tag in the document.","docstring_summary":"Returns the siblings of this Tag that match the given\n        criteria and appear before this Tag in the document.","docstring_tokens":["Returns","the","siblings","of","this","Tag","that","match","the","given","criteria","and","appear","before","this","Tag","in","the","document","."],"function":"def findPreviousSiblings(self, name=None, attrs={}, text=None,\n                             limit=None, **kwargs):\n        \"\"\"Returns the siblings of this Tag that match the given\n        criteria and appear before this Tag in the document.\"\"\"\n        return self._findAll(name, attrs, text, limit,\n                             self.previousSiblingGenerator, **kwargs)","function_tokens":["def","findPreviousSiblings","(","self",",","name","=","None",",","attrs","=","{","}",",","text","=","None",",","limit","=","None",",","*","*","kwargs",")",":","return","self",".","_findAll","(","name",",","attrs",",","text",",","limit",",","self",".","previousSiblingGenerator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L284-L289"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findParent","parameters":"(self, name=None, attrs={}, **kwargs)","argument_list":"","return_statement":"return r","docstring":"Returns the closest parent of this Tag that matches the given\n        criteria.","docstring_summary":"Returns the closest parent of this Tag that matches the given\n        criteria.","docstring_tokens":["Returns","the","closest","parent","of","this","Tag","that","matches","the","given","criteria","."],"function":"def findParent(self, name=None, attrs={}, **kwargs):\n        \"\"\"Returns the closest parent of this Tag that matches the given\n        criteria.\"\"\"\n        # NOTE: We can't use _findOne because findParents takes a different\n        # set of arguments.\n        r = None\n        l = self.findParents(name, attrs, 1)\n        if l:\n            r = l[0]\n        return r","function_tokens":["def","findParent","(","self",",","name","=","None",",","attrs","=","{","}",",","*","*","kwargs",")",":","# NOTE: We can't use _findOne because findParents takes a different","# set of arguments.","r","=","None","l","=","self",".","findParents","(","name",",","attrs",",","1",")","if","l",":","r","=","l","[","0","]","return","r"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L292-L301"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.findParents","parameters":"(self, name=None, attrs={}, limit=None, **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, None, limit, self.parentGenerator,\n                             **kwargs)","docstring":"Returns the parents of this Tag that match the given\n        criteria.","docstring_summary":"Returns the parents of this Tag that match the given\n        criteria.","docstring_tokens":["Returns","the","parents","of","this","Tag","that","match","the","given","criteria","."],"function":"def findParents(self, name=None, attrs={}, limit=None, **kwargs):\n        \"\"\"Returns the parents of this Tag that match the given\n        criteria.\"\"\"\n\n        return self._findAll(name, attrs, None, limit, self.parentGenerator,\n                             **kwargs)","function_tokens":["def","findParents","(","self",",","name","=","None",",","attrs","=","{","}",",","limit","=","None",",","*","*","kwargs",")",":","return","self",".","_findAll","(","name",",","attrs",",","None",",","limit",",","self",".","parentGenerator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L303-L308"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement._findAll","parameters":"(self, name, attrs, text, limit, generator, **kwargs)","argument_list":"","return_statement":"return results","docstring":"Iterates over a generator looking for things that match.","docstring_summary":"Iterates over a generator looking for things that match.","docstring_tokens":["Iterates","over","a","generator","looking","for","things","that","match","."],"function":"def _findAll(self, name, attrs, text, limit, generator, **kwargs):\n        \"Iterates over a generator looking for things that match.\"\n\n        if isinstance(name, SoupStrainer):\n            strainer = name\n        else:\n            # Build a SoupStrainer\n            strainer = SoupStrainer(name, attrs, text, **kwargs)\n        results = ResultSet(strainer)\n        g = generator()\n        while True:\n            try:\n                i = g.next()\n            except StopIteration:\n                break\n            if i:\n                found = strainer.search(i)\n                if found:\n                    results.append(found)\n                    if limit and len(results) >= limit:\n                        break\n        return results","function_tokens":["def","_findAll","(","self",",","name",",","attrs",",","text",",","limit",",","generator",",","*","*","kwargs",")",":","if","isinstance","(","name",",","SoupStrainer",")",":","strainer","=","name","else",":","# Build a SoupStrainer","strainer","=","SoupStrainer","(","name",",","attrs",",","text",",","*","*","kwargs",")","results","=","ResultSet","(","strainer",")","g","=","generator","(",")","while","True",":","try",":","i","=","g",".","next","(",")","except","StopIteration",":","break","if","i",":","found","=","strainer",".","search","(","i",")","if","found",":","results",".","append","(","found",")","if","limit","and","len","(","results",")",">=","limit",":","break","return","results"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L320-L341"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"PageElement.toEncoding","parameters":"(self, s, encoding=None)","argument_list":"","return_statement":"return s","docstring":"Encodes an object to a string in some encoding, or to Unicode.\n        .","docstring_summary":"Encodes an object to a string in some encoding, or to Unicode.\n        .","docstring_tokens":["Encodes","an","object","to","a","string","in","some","encoding","or","to","Unicode",".","."],"function":"def toEncoding(self, s, encoding=None):\n        \"\"\"Encodes an object to a string in some encoding, or to Unicode.\n        .\"\"\"\n        if isinstance(s, unicode):\n            if encoding:\n                s = s.encode(encoding)\n        elif isinstance(s, str):\n            if encoding:\n                s = s.encode(encoding)\n            else:\n                s = unicode(s)\n        else:\n            if encoding:\n                s  = self.toEncoding(str(s), encoding)\n            else:\n                s = unicode(s)\n        return s","function_tokens":["def","toEncoding","(","self",",","s",",","encoding","=","None",")",":","if","isinstance","(","s",",","unicode",")",":","if","encoding",":","s","=","s",".","encode","(","encoding",")","elif","isinstance","(","s",",","str",")",":","if","encoding",":","s","=","s",".","encode","(","encoding",")","else",":","s","=","unicode","(","s",")","else",":","if","encoding",":","s","=","self",".","toEncoding","(","str","(","s",")",",","encoding",")","else",":","s","=","unicode","(","s",")","return","s"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L380-L396"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"NavigableString.__new__","parameters":"(cls, value)","argument_list":"","return_statement":"return unicode.__new__(cls, value, DEFAULT_OUTPUT_ENCODING)","docstring":"Create a new NavigableString.\n\n        When unpickling a NavigableString, this method is called with\n        the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be\n        passed in to the superclass's __new__ or the superclass won't know\n        how to handle non-ASCII characters.","docstring_summary":"Create a new NavigableString.","docstring_tokens":["Create","a","new","NavigableString","."],"function":"def __new__(cls, value):\n        \"\"\"Create a new NavigableString.\n\n        When unpickling a NavigableString, this method is called with\n        the string in DEFAULT_OUTPUT_ENCODING. That encoding needs to be\n        passed in to the superclass's __new__ or the superclass won't know\n        how to handle non-ASCII characters.\n        \"\"\"\n        if isinstance(value, unicode):\n            return unicode.__new__(cls, value)\n        return unicode.__new__(cls, value, DEFAULT_OUTPUT_ENCODING)","function_tokens":["def","__new__","(","cls",",","value",")",":","if","isinstance","(","value",",","unicode",")",":","return","unicode",".","__new__","(","cls",",","value",")","return","unicode",".","__new__","(","cls",",","value",",","DEFAULT_OUTPUT_ENCODING",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L400-L410"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"NavigableString.__getattr__","parameters":"(self, attr)","argument_list":"","return_statement":"","docstring":"text.string gives you text. This is for backwards\n        compatibility for Navigable*String, but for CData* it lets you\n        get the string without the CData wrapper.","docstring_summary":"text.string gives you text. This is for backwards\n        compatibility for Navigable*String, but for CData* it lets you\n        get the string without the CData wrapper.","docstring_tokens":["text",".","string","gives","you","text",".","This","is","for","backwards","compatibility","for","Navigable","*","String","but","for","CData","*","it","lets","you","get","the","string","without","the","CData","wrapper","."],"function":"def __getattr__(self, attr):\n        \"\"\"text.string gives you text. This is for backwards\n        compatibility for Navigable*String, but for CData* it lets you\n        get the string without the CData wrapper.\"\"\"\n        if attr == 'string':\n            return self\n        else:\n            raise AttributeError, \"'%s' object has no attribute '%s'\" % (self.__class__.__name__, attr)","function_tokens":["def","__getattr__","(","self",",","attr",")",":","if","attr","==","'string'",":","return","self","else",":","raise","AttributeError",",","\"'%s' object has no attribute '%s'\"","%","(","self",".","__class__",".","__name__",",","attr",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L415-L422"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag._invert","parameters":"(h)","argument_list":"","return_statement":"return i","docstring":"Cheap function to invert a hash.","docstring_summary":"Cheap function to invert a hash.","docstring_tokens":["Cheap","function","to","invert","a","hash","."],"function":"def _invert(h):\n        \"Cheap function to invert a hash.\"\n        i = {}\n        for k,v in h.items():\n            i[v] = k\n        return i","function_tokens":["def","_invert","(","h",")",":","i","=","{","}","for","k",",","v","in","h",".","items","(",")",":","i","[","v","]","=","k","return","i"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L457-L462"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag._convertEntities","parameters":"(self, match)","argument_list":"","return_statement":"","docstring":"Used in a call to re.sub to replace HTML, XML, and numeric\n        entities with the appropriate Unicode characters. If HTML\n        entities are being converted, any unrecognized entities are\n        escaped.","docstring_summary":"Used in a call to re.sub to replace HTML, XML, and numeric\n        entities with the appropriate Unicode characters. If HTML\n        entities are being converted, any unrecognized entities are\n        escaped.","docstring_tokens":["Used","in","a","call","to","re",".","sub","to","replace","HTML","XML","and","numeric","entities","with","the","appropriate","Unicode","characters",".","If","HTML","entities","are","being","converted","any","unrecognized","entities","are","escaped","."],"function":"def _convertEntities(self, match):\n        \"\"\"Used in a call to re.sub to replace HTML, XML, and numeric\n        entities with the appropriate Unicode characters. If HTML\n        entities are being converted, any unrecognized entities are\n        escaped.\"\"\"\n        x = match.group(1)\n        if self.convertHTMLEntities and x in name2codepoint:\n            return unichr(name2codepoint[x])\n        elif x in self.XML_ENTITIES_TO_SPECIAL_CHARS:\n            if self.convertXMLEntities:\n                return self.XML_ENTITIES_TO_SPECIAL_CHARS[x]\n            else:\n                return u'&%s;' % x\n        elif len(x) > 0 and x[0] == '#':\n            # Handle numeric entities\n            if len(x) > 1 and x[1] == 'x':\n                return unichr(int(x[2:], 16))\n            else:\n                return unichr(int(x[1:]))\n\n        elif self.escapeUnrecognizedEntities:\n            return u'&amp;%s;' % x\n        else:\n            return u'&%s;' % x","function_tokens":["def","_convertEntities","(","self",",","match",")",":","x","=","match",".","group","(","1",")","if","self",".","convertHTMLEntities","and","x","in","name2codepoint",":","return","unichr","(","name2codepoint","[","x","]",")","elif","x","in","self",".","XML_ENTITIES_TO_SPECIAL_CHARS",":","if","self",".","convertXMLEntities",":","return","self",".","XML_ENTITIES_TO_SPECIAL_CHARS","[","x","]","else",":","return","u'&%s;'","%","x","elif","len","(","x",")",">","0","and","x","[","0","]","==","'#'",":","# Handle numeric entities","if","len","(","x",")",">","1","and","x","[","1","]","==","'x'",":","return","unichr","(","int","(","x","[","2",":","]",",","16",")",")","else",":","return","unichr","(","int","(","x","[","1",":","]",")",")","elif","self",".","escapeUnrecognizedEntities",":","return","u'&amp;%s;'","%","x","else",":","return","u'&%s;'","%","x"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L472-L495"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__init__","parameters":"(self, parser, name, attrs=None, parent=None,\n                 previous=None)","argument_list":"","return_statement":"","docstring":"Basic constructor.","docstring_summary":"Basic constructor.","docstring_tokens":["Basic","constructor","."],"function":"def __init__(self, parser, name, attrs=None, parent=None,\n                 previous=None):\n        \"Basic constructor.\"\n\n        # We don't actually store the parser object: that lets extracted\n        # chunks be garbage-collected\n        self.parserClass = parser.__class__\n        self.isSelfClosing = parser.isSelfClosingTag(name)\n        self.name = name\n        if attrs == None:\n            attrs = []\n        self.attrs = attrs\n        self.contents = []\n        self.setup(parent, previous)\n        self.hidden = False\n        self.containsSubstitutions = False\n        self.convertHTMLEntities = parser.convertHTMLEntities\n        self.convertXMLEntities = parser.convertXMLEntities\n        self.escapeUnrecognizedEntities = parser.escapeUnrecognizedEntities\n\n        # Convert any HTML, XML, or numeric entities in the attribute values.\n        convert = lambda(k, val): (k,\n                                   re.sub(\"&(#\\d+|#x[0-9a-fA-F]+|\\w+);\",\n                                          self._convertEntities,\n                                          val))\n        self.attrs = map(convert, self.attrs)","function_tokens":["def","__init__","(","self",",","parser",",","name",",","attrs","=","None",",","parent","=","None",",","previous","=","None",")",":","# We don't actually store the parser object: that lets extracted","# chunks be garbage-collected","self",".","parserClass","=","parser",".","__class__","self",".","isSelfClosing","=","parser",".","isSelfClosingTag","(","name",")","self",".","name","=","name","if","attrs","==","None",":","attrs","=","[","]","self",".","attrs","=","attrs","self",".","contents","=","[","]","self",".","setup","(","parent",",","previous",")","self",".","hidden","=","False","self",".","containsSubstitutions","=","False","self",".","convertHTMLEntities","=","parser",".","convertHTMLEntities","self",".","convertXMLEntities","=","parser",".","convertXMLEntities","self",".","escapeUnrecognizedEntities","=","parser",".","escapeUnrecognizedEntities","# Convert any HTML, XML, or numeric entities in the attribute values.","convert","=","lambda","(","k",",","val",")",":","(","k",",","re",".","sub","(","\"&(#\\d+|#x[0-9a-fA-F]+|\\w+);\"",",","self",".","_convertEntities",",","val",")",")","self",".","attrs","=","map","(","convert",",","self",".","attrs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L497-L522"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.get","parameters":"(self, key, default=None)","argument_list":"","return_statement":"return self._getAttrMap().get(key, default)","docstring":"Returns the value of the 'key' attribute for the tag, or\n        the value given for 'default' if it doesn't have that\n        attribute.","docstring_summary":"Returns the value of the 'key' attribute for the tag, or\n        the value given for 'default' if it doesn't have that\n        attribute.","docstring_tokens":["Returns","the","value","of","the","key","attribute","for","the","tag","or","the","value","given","for","default","if","it","doesn","t","have","that","attribute","."],"function":"def get(self, key, default=None):\n        \"\"\"Returns the value of the 'key' attribute for the tag, or\n        the value given for 'default' if it doesn't have that\n        attribute.\"\"\"\n        return self._getAttrMap().get(key, default)","function_tokens":["def","get","(","self",",","key",",","default","=","None",")",":","return","self",".","_getAttrMap","(",")",".","get","(","key",",","default",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L524-L528"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__getitem__","parameters":"(self, key)","argument_list":"","return_statement":"return self._getAttrMap()[key]","docstring":"tag[key] returns the value of the 'key' attribute for the tag,\n        and throws an exception if it's not there.","docstring_summary":"tag[key] returns the value of the 'key' attribute for the tag,\n        and throws an exception if it's not there.","docstring_tokens":["tag","[","key","]","returns","the","value","of","the","key","attribute","for","the","tag","and","throws","an","exception","if","it","s","not","there","."],"function":"def __getitem__(self, key):\n        \"\"\"tag[key] returns the value of the 'key' attribute for the tag,\n        and throws an exception if it's not there.\"\"\"\n        return self._getAttrMap()[key]","function_tokens":["def","__getitem__","(","self",",","key",")",":","return","self",".","_getAttrMap","(",")","[","key","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L533-L536"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__iter__","parameters":"(self)","argument_list":"","return_statement":"return iter(self.contents)","docstring":"Iterating over a tag iterates over its contents.","docstring_summary":"Iterating over a tag iterates over its contents.","docstring_tokens":["Iterating","over","a","tag","iterates","over","its","contents","."],"function":"def __iter__(self):\n        \"Iterating over a tag iterates over its contents.\"\n        return iter(self.contents)","function_tokens":["def","__iter__","(","self",")",":","return","iter","(","self",".","contents",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L538-L540"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__len__","parameters":"(self)","argument_list":"","return_statement":"return len(self.contents)","docstring":"The length of a tag is the length of its list of contents.","docstring_summary":"The length of a tag is the length of its list of contents.","docstring_tokens":["The","length","of","a","tag","is","the","length","of","its","list","of","contents","."],"function":"def __len__(self):\n        \"The length of a tag is the length of its list of contents.\"\n        return len(self.contents)","function_tokens":["def","__len__","(","self",")",":","return","len","(","self",".","contents",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L542-L544"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__nonzero__","parameters":"(self)","argument_list":"","return_statement":"return True","docstring":"A tag is non-None even if it has no contents.","docstring_summary":"A tag is non-None even if it has no contents.","docstring_tokens":["A","tag","is","non","-","None","even","if","it","has","no","contents","."],"function":"def __nonzero__(self):\n        \"A tag is non-None even if it has no contents.\"\n        return True","function_tokens":["def","__nonzero__","(","self",")",":","return","True"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L549-L551"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__setitem__","parameters":"(self, key, value)","argument_list":"","return_statement":"","docstring":"Setting tag[key] sets the value of the 'key' attribute for the\n        tag.","docstring_summary":"Setting tag[key] sets the value of the 'key' attribute for the\n        tag.","docstring_tokens":["Setting","tag","[","key","]","sets","the","value","of","the","key","attribute","for","the","tag","."],"function":"def __setitem__(self, key, value):\n        \"\"\"Setting tag[key] sets the value of the 'key' attribute for the\n        tag.\"\"\"\n        self._getAttrMap()\n        self.attrMap[key] = value\n        found = False\n        for i in range(0, len(self.attrs)):\n            if self.attrs[i][0] == key:\n                self.attrs[i] = (key, value)\n                found = True\n        if not found:\n            self.attrs.append((key, value))\n        self._getAttrMap()[key] = value","function_tokens":["def","__setitem__","(","self",",","key",",","value",")",":","self",".","_getAttrMap","(",")","self",".","attrMap","[","key","]","=","value","found","=","False","for","i","in","range","(","0",",","len","(","self",".","attrs",")",")",":","if","self",".","attrs","[","i","]","[","0","]","==","key",":","self",".","attrs","[","i","]","=","(","key",",","value",")","found","=","True","if","not","found",":","self",".","attrs",".","append","(","(","key",",","value",")",")","self",".","_getAttrMap","(",")","[","key","]","=","value"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L553-L565"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__delitem__","parameters":"(self, key)","argument_list":"","return_statement":"","docstring":"Deleting tag[key] deletes all 'key' attributes for the tag.","docstring_summary":"Deleting tag[key] deletes all 'key' attributes for the tag.","docstring_tokens":["Deleting","tag","[","key","]","deletes","all","key","attributes","for","the","tag","."],"function":"def __delitem__(self, key):\n        \"Deleting tag[key] deletes all 'key' attributes for the tag.\"\n        for item in self.attrs:\n            if item[0] == key:\n                self.attrs.remove(item)\n                #We don't break because bad HTML can define the same\n                #attribute multiple times.\n            self._getAttrMap()\n            if self.attrMap.has_key(key):\n                del self.attrMap[key]","function_tokens":["def","__delitem__","(","self",",","key",")",":","for","item","in","self",".","attrs",":","if","item","[","0","]","==","key",":","self",".","attrs",".","remove","(","item",")","#We don't break because bad HTML can define the same","#attribute multiple times.","self",".","_getAttrMap","(",")","if","self",".","attrMap",".","has_key","(","key",")",":","del","self",".","attrMap","[","key","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L567-L576"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__call__","parameters":"(self, *args, **kwargs)","argument_list":"","return_statement":"return apply(self.findAll, args, kwargs)","docstring":"Calling a tag like a function is the same as calling its\n        findAll() method. Eg. tag('a') returns a list of all the A tags\n        found within this tag.","docstring_summary":"Calling a tag like a function is the same as calling its\n        findAll() method. Eg. tag('a') returns a list of all the A tags\n        found within this tag.","docstring_tokens":["Calling","a","tag","like","a","function","is","the","same","as","calling","its","findAll","()","method",".","Eg",".","tag","(","a",")","returns","a","list","of","all","the","A","tags","found","within","this","tag","."],"function":"def __call__(self, *args, **kwargs):\n        \"\"\"Calling a tag like a function is the same as calling its\n        findAll() method. Eg. tag('a') returns a list of all the A tags\n        found within this tag.\"\"\"\n        return apply(self.findAll, args, kwargs)","function_tokens":["def","__call__","(","self",",","*","args",",","*","*","kwargs",")",":","return","apply","(","self",".","findAll",",","args",",","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L578-L582"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__eq__","parameters":"(self, other)","argument_list":"","return_statement":"return True","docstring":"Returns true iff this tag has the same name, the same attributes,\n        and the same contents (recursively) as the given tag.\n\n        NOTE: right now this will return false if two tags have the\n        same attributes in a different order. Should this be fixed?","docstring_summary":"Returns true iff this tag has the same name, the same attributes,\n        and the same contents (recursively) as the given tag.","docstring_tokens":["Returns","true","iff","this","tag","has","the","same","name","the","same","attributes","and","the","same","contents","(","recursively",")","as","the","given","tag","."],"function":"def __eq__(self, other):\n        \"\"\"Returns true iff this tag has the same name, the same attributes,\n        and the same contents (recursively) as the given tag.\n\n        NOTE: right now this will return false if two tags have the\n        same attributes in a different order. Should this be fixed?\"\"\"\n        if not hasattr(other, 'name') or not hasattr(other, 'attrs') or not hasattr(other, 'contents') or self.name != other.name or self.attrs != other.attrs or len(self) != len(other):\n            return False\n        for i in range(0, len(self.contents)):\n            if self.contents[i] != other.contents[i]:\n                return False\n        return True","function_tokens":["def","__eq__","(","self",",","other",")",":","if","not","hasattr","(","other",",","'name'",")","or","not","hasattr","(","other",",","'attrs'",")","or","not","hasattr","(","other",",","'contents'",")","or","self",".","name","!=","other",".","name","or","self",".","attrs","!=","other",".","attrs","or","len","(","self",")","!=","len","(","other",")",":","return","False","for","i","in","range","(","0",",","len","(","self",".","contents",")",")",":","if","self",".","contents","[","i","]","!=","other",".","contents","[","i","]",":","return","False","return","True"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L592-L603"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__ne__","parameters":"(self, other)","argument_list":"","return_statement":"return not self == other","docstring":"Returns true iff this tag is not identical to the other tag,\n        as defined in __eq__.","docstring_summary":"Returns true iff this tag is not identical to the other tag,\n        as defined in __eq__.","docstring_tokens":["Returns","true","iff","this","tag","is","not","identical","to","the","other","tag","as","defined","in","__eq__","."],"function":"def __ne__(self, other):\n        \"\"\"Returns true iff this tag is not identical to the other tag,\n        as defined in __eq__.\"\"\"\n        return not self == other","function_tokens":["def","__ne__","(","self",",","other",")",":","return","not","self","==","other"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L605-L608"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__repr__","parameters":"(self, encoding=DEFAULT_OUTPUT_ENCODING)","argument_list":"","return_statement":"return self.__str__(encoding)","docstring":"Renders this tag as a string.","docstring_summary":"Renders this tag as a string.","docstring_tokens":["Renders","this","tag","as","a","string","."],"function":"def __repr__(self, encoding=DEFAULT_OUTPUT_ENCODING):\n        \"\"\"Renders this tag as a string.\"\"\"\n        return self.__str__(encoding)","function_tokens":["def","__repr__","(","self",",","encoding","=","DEFAULT_OUTPUT_ENCODING",")",":","return","self",".","__str__","(","encoding",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L610-L612"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag._sub_entity","parameters":"(self, x)","argument_list":"","return_statement":"return \"&\" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + \";\"","docstring":"Used with a regular expression to substitute the\n        appropriate XML entity for an XML special character.","docstring_summary":"Used with a regular expression to substitute the\n        appropriate XML entity for an XML special character.","docstring_tokens":["Used","with","a","regular","expression","to","substitute","the","appropriate","XML","entity","for","an","XML","special","character","."],"function":"def _sub_entity(self, x):\n        \"\"\"Used with a regular expression to substitute the\n        appropriate XML entity for an XML special character.\"\"\"\n        return \"&\" + self.XML_SPECIAL_CHARS_TO_ENTITIES[x.group(0)[0]] + \";\"","function_tokens":["def","_sub_entity","(","self",",","x",")",":","return","\"&\"","+","self",".","XML_SPECIAL_CHARS_TO_ENTITIES","[","x",".","group","(","0",")","[","0","]","]","+","\";\""],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L621-L624"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.__str__","parameters":"(self, encoding=DEFAULT_OUTPUT_ENCODING,\n                prettyPrint=False, indentLevel=0)","argument_list":"","return_statement":"return s","docstring":"Returns a string or Unicode representation of this tag and\n        its contents. To get Unicode, pass None for encoding.\n\n        NOTE: since Python's HTML parser consumes whitespace, this\n        method is not certain to reproduce the whitespace present in\n        the original string.","docstring_summary":"Returns a string or Unicode representation of this tag and\n        its contents. To get Unicode, pass None for encoding.","docstring_tokens":["Returns","a","string","or","Unicode","representation","of","this","tag","and","its","contents",".","To","get","Unicode","pass","None","for","encoding","."],"function":"def __str__(self, encoding=DEFAULT_OUTPUT_ENCODING,\n                prettyPrint=False, indentLevel=0):\n        \"\"\"Returns a string or Unicode representation of this tag and\n        its contents. To get Unicode, pass None for encoding.\n\n        NOTE: since Python's HTML parser consumes whitespace, this\n        method is not certain to reproduce the whitespace present in\n        the original string.\"\"\"\n\n        encodedName = self.toEncoding(self.name, encoding)\n\n        attrs = []\n        if self.attrs:\n            for key, val in self.attrs:\n                fmt = '%s=\"%s\"'\n                if isString(val):\n                    if self.containsSubstitutions and '%SOUP-ENCODING%' in val:\n                        val = self.substituteEncoding(val, encoding)\n\n                    # The attribute value either:\n                    #\n                    # * Contains no embedded double quotes or single quotes.\n                    #   No problem: we enclose it in double quotes.\n                    # * Contains embedded single quotes. No problem:\n                    #   double quotes work here too.\n                    # * Contains embedded double quotes. No problem:\n                    #   we enclose it in single quotes.\n                    # * Embeds both single _and_ double quotes. This\n                    #   can't happen naturally, but it can happen if\n                    #   you modify an attribute value after parsing\n                    #   the document. Now we have a bit of a\n                    #   problem. We solve it by enclosing the\n                    #   attribute in single quotes, and escaping any\n                    #   embedded single quotes to XML entities.\n                    if '\"' in val:\n                        fmt = \"%s='%s'\"\n                        if \"'\" in val:\n                            # TODO: replace with apos when\n                            # appropriate.\n                            val = val.replace(\"'\", \"&squot;\")\n\n                    # Now we're okay w\/r\/t quotes. But the attribute\n                    # value might also contain angle brackets, or\n                    # ampersands that aren't part of entities. We need\n                    # to escape those to XML entities too.\n                    val = self.BARE_AMPERSAND_OR_BRACKET.sub(self._sub_entity, val)\n\n                attrs.append(fmt % (self.toEncoding(key, encoding),\n                                    self.toEncoding(val, encoding)))\n        close = ''\n        closeTag = ''\n        if self.isSelfClosing:\n            close = ' \/'\n        else:\n            closeTag = '<\/%s>' % encodedName\n\n        indentTag, indentContents = 0, 0\n        if prettyPrint:\n            indentTag = indentLevel\n            space = (' ' * (indentTag-1))\n            indentContents = indentTag + 1\n        contents = self.renderContents(encoding, prettyPrint, indentContents)\n        if self.hidden:\n            s = contents\n        else:\n            s = []\n            attributeString = ''\n            if attrs:\n                attributeString = ' ' + ' '.join(attrs)\n            if prettyPrint:\n                s.append(space)\n            s.append('<%s%s%s>' % (encodedName, attributeString, close))\n            if prettyPrint:\n                s.append(\"\\n\")\n            s.append(contents)\n            if prettyPrint and contents and contents[-1] != \"\\n\":\n                s.append(\"\\n\")\n            if prettyPrint and closeTag:\n                s.append(space)\n            s.append(closeTag)\n            if prettyPrint and closeTag and self.nextSibling:\n                s.append(\"\\n\")\n            s = ''.join(s)\n        return s","function_tokens":["def","__str__","(","self",",","encoding","=","DEFAULT_OUTPUT_ENCODING",",","prettyPrint","=","False",",","indentLevel","=","0",")",":","encodedName","=","self",".","toEncoding","(","self",".","name",",","encoding",")","attrs","=","[","]","if","self",".","attrs",":","for","key",",","val","in","self",".","attrs",":","fmt","=","'%s=\"%s\"'","if","isString","(","val",")",":","if","self",".","containsSubstitutions","and","'%SOUP-ENCODING%'","in","val",":","val","=","self",".","substituteEncoding","(","val",",","encoding",")","# The attribute value either:","#","# * Contains no embedded double quotes or single quotes.","#   No problem: we enclose it in double quotes.","# * Contains embedded single quotes. No problem:","#   double quotes work here too.","# * Contains embedded double quotes. No problem:","#   we enclose it in single quotes.","# * Embeds both single _and_ double quotes. This","#   can't happen naturally, but it can happen if","#   you modify an attribute value after parsing","#   the document. Now we have a bit of a","#   problem. We solve it by enclosing the","#   attribute in single quotes, and escaping any","#   embedded single quotes to XML entities.","if","'\"'","in","val",":","fmt","=","\"%s='%s'\"","if","\"'\"","in","val",":","# TODO: replace with apos when","# appropriate.","val","=","val",".","replace","(","\"'\"",",","\"&squot;\"",")","# Now we're okay w\/r\/t quotes. But the attribute","# value might also contain angle brackets, or","# ampersands that aren't part of entities. We need","# to escape those to XML entities too.","val","=","self",".","BARE_AMPERSAND_OR_BRACKET",".","sub","(","self",".","_sub_entity",",","val",")","attrs",".","append","(","fmt","%","(","self",".","toEncoding","(","key",",","encoding",")",",","self",".","toEncoding","(","val",",","encoding",")",")",")","close","=","''","closeTag","=","''","if","self",".","isSelfClosing",":","close","=","' \/'","else",":","closeTag","=","'<\/%s>'","%","encodedName","indentTag",",","indentContents","=","0",",","0","if","prettyPrint",":","indentTag","=","indentLevel","space","=","(","' '","*","(","indentTag","-","1",")",")","indentContents","=","indentTag","+","1","contents","=","self",".","renderContents","(","encoding",",","prettyPrint",",","indentContents",")","if","self",".","hidden",":","s","=","contents","else",":","s","=","[","]","attributeString","=","''","if","attrs",":","attributeString","=","' '","+","' '",".","join","(","attrs",")","if","prettyPrint",":","s",".","append","(","space",")","s",".","append","(","'<%s%s%s>'","%","(","encodedName",",","attributeString",",","close",")",")","if","prettyPrint",":","s",".","append","(","\"\\n\"",")","s",".","append","(","contents",")","if","prettyPrint","and","contents","and","contents","[","-","1","]","!=","\"\\n\"",":","s",".","append","(","\"\\n\"",")","if","prettyPrint","and","closeTag",":","s",".","append","(","space",")","s",".","append","(","closeTag",")","if","prettyPrint","and","closeTag","and","self",".","nextSibling",":","s",".","append","(","\"\\n\"",")","s","=","''",".","join","(","s",")","return","s"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L626-L709"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.decompose","parameters":"(self)","argument_list":"","return_statement":"","docstring":"Recursively destroys the contents of this tree.","docstring_summary":"Recursively destroys the contents of this tree.","docstring_tokens":["Recursively","destroys","the","contents","of","this","tree","."],"function":"def decompose(self):\n        \"\"\"Recursively destroys the contents of this tree.\"\"\"\n        contents = [i for i in self.contents]\n        for i in contents:\n            if isinstance(i, Tag):\n                i.decompose()\n            else:\n                i.extract()\n        self.extract()","function_tokens":["def","decompose","(","self",")",":","contents","=","[","i","for","i","in","self",".","contents","]","for","i","in","contents",":","if","isinstance","(","i",",","Tag",")",":","i",".","decompose","(",")","else",":","i",".","extract","(",")","self",".","extract","(",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L711-L719"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.renderContents","parameters":"(self, encoding=DEFAULT_OUTPUT_ENCODING,\n                       prettyPrint=False, indentLevel=0)","argument_list":"","return_statement":"return ''.join(s)","docstring":"Renders the contents of this tag as a string in the given\n        encoding. If encoding is None, returns a Unicode string..","docstring_summary":"Renders the contents of this tag as a string in the given\n        encoding. If encoding is None, returns a Unicode string..","docstring_tokens":["Renders","the","contents","of","this","tag","as","a","string","in","the","given","encoding",".","If","encoding","is","None","returns","a","Unicode","string",".."],"function":"def renderContents(self, encoding=DEFAULT_OUTPUT_ENCODING,\n                       prettyPrint=False, indentLevel=0):\n        \"\"\"Renders the contents of this tag as a string in the given\n        encoding. If encoding is None, returns a Unicode string..\"\"\"\n        s=[]\n        for c in self:\n            text = None\n            if isinstance(c, NavigableString):\n                text = c.__str__(encoding)\n            elif isinstance(c, Tag):\n                s.append(c.__str__(encoding, prettyPrint, indentLevel))\n            if text and prettyPrint:\n                text = text.strip()\n            if text:\n                if prettyPrint:\n                    s.append(\" \" * (indentLevel-1))\n                s.append(text)\n                if prettyPrint:\n                    s.append(\"\\n\")\n        return ''.join(s)","function_tokens":["def","renderContents","(","self",",","encoding","=","DEFAULT_OUTPUT_ENCODING",",","prettyPrint","=","False",",","indentLevel","=","0",")",":","s","=","[","]","for","c","in","self",":","text","=","None","if","isinstance","(","c",",","NavigableString",")",":","text","=","c",".","__str__","(","encoding",")","elif","isinstance","(","c",",","Tag",")",":","s",".","append","(","c",".","__str__","(","encoding",",","prettyPrint",",","indentLevel",")",")","if","text","and","prettyPrint",":","text","=","text",".","strip","(",")","if","text",":","if","prettyPrint",":","s",".","append","(","\" \"","*","(","indentLevel","-","1",")",")","s",".","append","(","text",")","if","prettyPrint",":","s",".","append","(","\"\\n\"",")","return","''",".","join","(","s",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L724-L743"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.find","parameters":"(self, name=None, attrs={}, recursive=True, text=None,\n             **kwargs)","argument_list":"","return_statement":"return r","docstring":"Return only the first child of this Tag matching the given\n        criteria.","docstring_summary":"Return only the first child of this Tag matching the given\n        criteria.","docstring_tokens":["Return","only","the","first","child","of","this","Tag","matching","the","given","criteria","."],"function":"def find(self, name=None, attrs={}, recursive=True, text=None,\n             **kwargs):\n        \"\"\"Return only the first child of this Tag matching the given\n        criteria.\"\"\"\n        r = None\n        l = self.findAll(name, attrs, recursive, text, 1, **kwargs)\n        if l:\n            r = l[0]\n        return r","function_tokens":["def","find","(","self",",","name","=","None",",","attrs","=","{","}",",","recursive","=","True",",","text","=","None",",","*","*","kwargs",")",":","r","=","None","l","=","self",".","findAll","(","name",",","attrs",",","recursive",",","text",",","1",",","*","*","kwargs",")","if","l",":","r","=","l","[","0","]","return","r"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L747-L755"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag.findAll","parameters":"(self, name=None, attrs={}, recursive=True, text=None,\n                limit=None, **kwargs)","argument_list":"","return_statement":"return self._findAll(name, attrs, text, limit, generator, **kwargs)","docstring":"Extracts a list of Tag objects that match the given\n        criteria.  You can specify the name of the Tag and any\n        attributes you want the Tag to have.\n\n        The value of a key-value pair in the 'attrs' map can be a\n        string, a list of strings, a regular expression object, or a\n        callable that takes a string and returns whether or not the\n        string matches for some custom definition of 'matches'. The\n        same is true of the tag name.","docstring_summary":"Extracts a list of Tag objects that match the given\n        criteria.  You can specify the name of the Tag and any\n        attributes you want the Tag to have.","docstring_tokens":["Extracts","a","list","of","Tag","objects","that","match","the","given","criteria",".","You","can","specify","the","name","of","the","Tag","and","any","attributes","you","want","the","Tag","to","have","."],"function":"def findAll(self, name=None, attrs={}, recursive=True, text=None,\n                limit=None, **kwargs):\n        \"\"\"Extracts a list of Tag objects that match the given\n        criteria.  You can specify the name of the Tag and any\n        attributes you want the Tag to have.\n\n        The value of a key-value pair in the 'attrs' map can be a\n        string, a list of strings, a regular expression object, or a\n        callable that takes a string and returns whether or not the\n        string matches for some custom definition of 'matches'. The\n        same is true of the tag name.\"\"\"\n        generator = self.recursiveChildGenerator\n        if not recursive:\n            generator = self.childGenerator\n        return self._findAll(name, attrs, text, limit, generator, **kwargs)","function_tokens":["def","findAll","(","self",",","name","=","None",",","attrs","=","{","}",",","recursive","=","True",",","text","=","None",",","limit","=","None",",","*","*","kwargs",")",":","generator","=","self",".","recursiveChildGenerator","if","not","recursive",":","generator","=","self",".","childGenerator","return","self",".","_findAll","(","name",",","attrs",",","text",",","limit",",","generator",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L758-L772"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"Tag._getAttrMap","parameters":"(self)","argument_list":"","return_statement":"return self.attrMap","docstring":"Initializes a map representation of this tag's attributes,\n        if not already initialized.","docstring_summary":"Initializes a map representation of this tag's attributes,\n        if not already initialized.","docstring_tokens":["Initializes","a","map","representation","of","this","tag","s","attributes","if","not","already","initialized","."],"function":"def _getAttrMap(self):\n        \"\"\"Initializes a map representation of this tag's attributes,\n        if not already initialized.\"\"\"\n        if not getattr(self, 'attrMap'):\n            self.attrMap = {}\n            for (key, value) in self.attrs:\n                self.attrMap[key] = value\n        return self.attrMap","function_tokens":["def","_getAttrMap","(","self",")",":","if","not","getattr","(","self",",","'attrMap'",")",":","self",".","attrMap","=","{","}","for","(","key",",","value",")","in","self",".","attrs",":","self",".","attrMap","[","key","]","=","value","return","self",".","attrMap"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L787-L794"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.__init__","parameters":"(self, markup=\"\", parseOnlyThese=None, fromEncoding=None,\n                 markupMassage=True, smartQuotesTo=XML_ENTITIES,\n                 convertEntities=None, selfClosingTags=None, isHTML=False)","argument_list":"","return_statement":"","docstring":"The Soup object is initialized as the 'root tag', and the\n        provided markup (which can be a string or a file-like object)\n        is fed into the underlying parser.\n\n        sgmllib will process most bad HTML, and the BeautifulSoup\n        class has some tricks for dealing with some HTML that kills\n        sgmllib, but Beautiful Soup can nonetheless choke or lose data\n        if your data uses self-closing tags or declarations\n        incorrectly.\n\n        By default, Beautiful Soup uses regexes to sanitize input,\n        avoiding the vast majority of these problems. If the problems\n        don't apply to you, pass in False for markupMassage, and\n        you'll get better performance.\n\n        The default parser massage techniques fix the two most common\n        instances of invalid HTML that choke sgmllib:\n\n         <br\/> (No space between name of closing tag and tag close)\n         <! --Comment--> (Extraneous whitespace in declaration)\n\n        You can pass in a custom list of (RE object, replace method)\n        tuples to get Beautiful Soup to scrub your input the way you\n        want.","docstring_summary":"The Soup object is initialized as the 'root tag', and the\n        provided markup (which can be a string or a file-like object)\n        is fed into the underlying parser.","docstring_tokens":["The","Soup","object","is","initialized","as","the","root","tag","and","the","provided","markup","(","which","can","be","a","string","or","a","file","-","like","object",")","is","fed","into","the","underlying","parser","."],"function":"def __init__(self, markup=\"\", parseOnlyThese=None, fromEncoding=None,\n                 markupMassage=True, smartQuotesTo=XML_ENTITIES,\n                 convertEntities=None, selfClosingTags=None, isHTML=False):\n        \"\"\"The Soup object is initialized as the 'root tag', and the\n        provided markup (which can be a string or a file-like object)\n        is fed into the underlying parser.\n\n        sgmllib will process most bad HTML, and the BeautifulSoup\n        class has some tricks for dealing with some HTML that kills\n        sgmllib, but Beautiful Soup can nonetheless choke or lose data\n        if your data uses self-closing tags or declarations\n        incorrectly.\n\n        By default, Beautiful Soup uses regexes to sanitize input,\n        avoiding the vast majority of these problems. If the problems\n        don't apply to you, pass in False for markupMassage, and\n        you'll get better performance.\n\n        The default parser massage techniques fix the two most common\n        instances of invalid HTML that choke sgmllib:\n\n         <br\/> (No space between name of closing tag and tag close)\n         <! --Comment--> (Extraneous whitespace in declaration)\n\n        You can pass in a custom list of (RE object, replace method)\n        tuples to get Beautiful Soup to scrub your input the way you\n        want.\"\"\"\n\n        self.parseOnlyThese = parseOnlyThese\n        self.fromEncoding = fromEncoding\n        self.smartQuotesTo = smartQuotesTo\n        self.convertEntities = convertEntities\n        # Set the rules for how we'll deal with the entities we\n        # encounter\n        if self.convertEntities:\n            # It doesn't make sense to convert encoded characters to\n            # entities even while you're converting entities to Unicode.\n            # Just convert it all to Unicode.\n            self.smartQuotesTo = None\n            if convertEntities == self.HTML_ENTITIES:\n                self.convertXMLEntities = False\n                self.convertHTMLEntities = True\n                self.escapeUnrecognizedEntities = True\n            elif convertEntities == self.XHTML_ENTITIES:\n                self.convertXMLEntities = True\n                self.convertHTMLEntities = True\n                self.escapeUnrecognizedEntities = False\n            elif convertEntities == self.XML_ENTITIES:\n                self.convertXMLEntities = True\n                self.convertHTMLEntities = False\n                self.escapeUnrecognizedEntities = False\n        else:\n            self.convertXMLEntities = False\n            self.convertHTMLEntities = False\n            self.escapeUnrecognizedEntities = False\n\n        self.instanceSelfClosingTags = buildTagMap(None, selfClosingTags)\n        SGMLParser.__init__(self)\n\n        if hasattr(markup, 'read'):        # It's a file-type object.\n            markup = markup.read()\n        self.markup = markup\n        self.markupMassage = markupMassage\n        try:\n            self._feed(isHTML=isHTML)\n        except StopParsing:\n            pass\n        self.markup = None","function_tokens":["def","__init__","(","self",",","markup","=","\"\"",",","parseOnlyThese","=","None",",","fromEncoding","=","None",",","markupMassage","=","True",",","smartQuotesTo","=","XML_ENTITIES",",","convertEntities","=","None",",","selfClosingTags","=","None",",","isHTML","=","False",")",":","self",".","parseOnlyThese","=","parseOnlyThese","self",".","fromEncoding","=","fromEncoding","self",".","smartQuotesTo","=","smartQuotesTo","self",".","convertEntities","=","convertEntities","# Set the rules for how we'll deal with the entities we","# encounter","if","self",".","convertEntities",":","# It doesn't make sense to convert encoded characters to","# entities even while you're converting entities to Unicode.","# Just convert it all to Unicode.","self",".","smartQuotesTo","=","None","if","convertEntities","==","self",".","HTML_ENTITIES",":","self",".","convertXMLEntities","=","False","self",".","convertHTMLEntities","=","True","self",".","escapeUnrecognizedEntities","=","True","elif","convertEntities","==","self",".","XHTML_ENTITIES",":","self",".","convertXMLEntities","=","True","self",".","convertHTMLEntities","=","True","self",".","escapeUnrecognizedEntities","=","False","elif","convertEntities","==","self",".","XML_ENTITIES",":","self",".","convertXMLEntities","=","True","self",".","convertHTMLEntities","=","False","self",".","escapeUnrecognizedEntities","=","False","else",":","self",".","convertXMLEntities","=","False","self",".","convertHTMLEntities","=","False","self",".","escapeUnrecognizedEntities","=","False","self",".","instanceSelfClosingTags","=","buildTagMap","(","None",",","selfClosingTags",")","SGMLParser",".","__init__","(","self",")","if","hasattr","(","markup",",","'read'",")",":","# It's a file-type object.","markup","=","markup",".","read","(",")","self",".","markup","=","markup","self",".","markupMassage","=","markupMassage","try",":","self",".","_feed","(","isHTML","=","isHTML",")","except","StopParsing",":","pass","self",".","markup","=","None"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1025-L1092"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.convert_charref","parameters":"(self, name)","argument_list":"","return_statement":"return self.convert_codepoint(n)","docstring":"This method fixes a bug in Python's SGMLParser.","docstring_summary":"This method fixes a bug in Python's SGMLParser.","docstring_tokens":["This","method","fixes","a","bug","in","Python","s","SGMLParser","."],"function":"def convert_charref(self, name):\n        \"\"\"This method fixes a bug in Python's SGMLParser.\"\"\"\n        try:\n            n = int(name)\n        except ValueError:\n            return\n        if not 0 <= n <= 127 : # ASCII ends at 127, not 255\n            return\n        return self.convert_codepoint(n)","function_tokens":["def","convert_charref","(","self",",","name",")",":","try",":","n","=","int","(","name",")","except","ValueError",":","return","if","not","0","<=","n","<=","127",":","# ASCII ends at 127, not 255","return","return","self",".","convert_codepoint","(","n",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1094-L1102"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.__getattr__","parameters":"(self, methodName)","argument_list":"","return_statement":"","docstring":"This method routes method call requests to either the SGMLParser\n        superclass or the Tag superclass, depending on the method name.","docstring_summary":"This method routes method call requests to either the SGMLParser\n        superclass or the Tag superclass, depending on the method name.","docstring_tokens":["This","method","routes","method","call","requests","to","either","the","SGMLParser","superclass","or","the","Tag","superclass","depending","on","the","method","name","."],"function":"def __getattr__(self, methodName):\n        \"\"\"This method routes method call requests to either the SGMLParser\n        superclass or the Tag superclass, depending on the method name.\"\"\"\n        #print \"__getattr__ called on %s.%s\" % (self.__class__, methodName)\n\n        if methodName.find('start_') == 0 or methodName.find('end_') == 0 \\\n               or methodName.find('do_') == 0:\n            return SGMLParser.__getattr__(self, methodName)\n        elif methodName.find('__') != 0:\n            return Tag.__getattr__(self, methodName)\n        else:\n            raise AttributeError","function_tokens":["def","__getattr__","(","self",",","methodName",")",":","#print \"__getattr__ called on %s.%s\" % (self.__class__, methodName)","if","methodName",".","find","(","'start_'",")","==","0","or","methodName",".","find","(","'end_'",")","==","0","or","methodName",".","find","(","'do_'",")","==","0",":","return","SGMLParser",".","__getattr__","(","self",",","methodName",")","elif","methodName",".","find","(","'__'",")","!=","0",":","return","Tag",".","__getattr__","(","self",",","methodName",")","else",":","raise","AttributeError"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1137-L1148"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.isSelfClosingTag","parameters":"(self, name)","argument_list":"","return_statement":"return self.SELF_CLOSING_TAGS.has_key(name) \\\n               or self.instanceSelfClosingTags.has_key(name)","docstring":"Returns true iff the given string is the name of a\n        self-closing tag according to this parser.","docstring_summary":"Returns true iff the given string is the name of a\n        self-closing tag according to this parser.","docstring_tokens":["Returns","true","iff","the","given","string","is","the","name","of","a","self","-","closing","tag","according","to","this","parser","."],"function":"def isSelfClosingTag(self, name):\n        \"\"\"Returns true iff the given string is the name of a\n        self-closing tag according to this parser.\"\"\"\n        return self.SELF_CLOSING_TAGS.has_key(name) \\\n               or self.instanceSelfClosingTags.has_key(name)","function_tokens":["def","isSelfClosingTag","(","self",",","name",")",":","return","self",".","SELF_CLOSING_TAGS",".","has_key","(","name",")","or","self",".","instanceSelfClosingTags",".","has_key","(","name",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1150-L1154"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup._popToTag","parameters":"(self, name, inclusivePop=True)","argument_list":"","return_statement":"return mostRecentTag","docstring":"Pops the tag stack up to and including the most recent\n        instance of the given tag. If inclusivePop is false, pops the tag\n        stack up to but *not* including the most recent instqance of\n        the given tag.","docstring_summary":"Pops the tag stack up to and including the most recent\n        instance of the given tag. If inclusivePop is false, pops the tag\n        stack up to but *not* including the most recent instqance of\n        the given tag.","docstring_tokens":["Pops","the","tag","stack","up","to","and","including","the","most","recent","instance","of","the","given","tag",".","If","inclusivePop","is","false","pops","the","tag","stack","up","to","but","*","not","*","including","the","most","recent","instqance","of","the","given","tag","."],"function":"def _popToTag(self, name, inclusivePop=True):\n        \"\"\"Pops the tag stack up to and including the most recent\n        instance of the given tag. If inclusivePop is false, pops the tag\n        stack up to but *not* including the most recent instqance of\n        the given tag.\"\"\"\n        #print \"Popping to %s\" % name\n        if name == self.ROOT_TAG_NAME:\n            return\n\n        numPops = 0\n        mostRecentTag = None\n        for i in range(len(self.tagStack)-1, 0, -1):\n            if name == self.tagStack[i].name:\n                numPops = len(self.tagStack)-i\n                break\n        if not inclusivePop:\n            numPops = numPops - 1\n\n        for i in range(0, numPops):\n            mostRecentTag = self.popTag()\n        return mostRecentTag","function_tokens":["def","_popToTag","(","self",",","name",",","inclusivePop","=","True",")",":","#print \"Popping to %s\" % name","if","name","==","self",".","ROOT_TAG_NAME",":","return","numPops","=","0","mostRecentTag","=","None","for","i","in","range","(","len","(","self",".","tagStack",")","-","1",",","0",",","-","1",")",":","if","name","==","self",".","tagStack","[","i","]",".","name",":","numPops","=","len","(","self",".","tagStack",")","-","i","break","if","not","inclusivePop",":","numPops","=","numPops","-","1","for","i","in","range","(","0",",","numPops",")",":","mostRecentTag","=","self",".","popTag","(",")","return","mostRecentTag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1210-L1230"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup._smartPop","parameters":"(self, name)","argument_list":"","return_statement":"","docstring":"We need to pop up to the previous tag of this type, unless\n        one of this tag's nesting reset triggers comes between this\n        tag and the previous tag of this type, OR unless this tag is a\n        generic nesting trigger and another generic nesting trigger\n        comes between this tag and the previous tag of this type.\n\n        Examples:\n         <p>Foo<b>Bar *<p>* should pop to 'p', not 'b'.\n         <p>Foo<table>Bar *<p>* should pop to 'table', not 'p'.\n         <p>Foo<table><tr>Bar *<p>* should pop to 'tr', not 'p'.\n\n         <li><ul><li> *<li>* should pop to 'ul', not the first 'li'.\n         <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr'\n         <td><tr><td> *<td>* should pop to 'tr', not the first 'td'","docstring_summary":"We need to pop up to the previous tag of this type, unless\n        one of this tag's nesting reset triggers comes between this\n        tag and the previous tag of this type, OR unless this tag is a\n        generic nesting trigger and another generic nesting trigger\n        comes between this tag and the previous tag of this type.","docstring_tokens":["We","need","to","pop","up","to","the","previous","tag","of","this","type","unless","one","of","this","tag","s","nesting","reset","triggers","comes","between","this","tag","and","the","previous","tag","of","this","type","OR","unless","this","tag","is","a","generic","nesting","trigger","and","another","generic","nesting","trigger","comes","between","this","tag","and","the","previous","tag","of","this","type","."],"function":"def _smartPop(self, name):\n\n        \"\"\"We need to pop up to the previous tag of this type, unless\n        one of this tag's nesting reset triggers comes between this\n        tag and the previous tag of this type, OR unless this tag is a\n        generic nesting trigger and another generic nesting trigger\n        comes between this tag and the previous tag of this type.\n\n        Examples:\n         <p>Foo<b>Bar *<p>* should pop to 'p', not 'b'.\n         <p>Foo<table>Bar *<p>* should pop to 'table', not 'p'.\n         <p>Foo<table><tr>Bar *<p>* should pop to 'tr', not 'p'.\n\n         <li><ul><li> *<li>* should pop to 'ul', not the first 'li'.\n         <tr><table><tr> *<tr>* should pop to 'table', not the first 'tr'\n         <td><tr><td> *<td>* should pop to 'tr', not the first 'td'\n        \"\"\"\n\n        nestingResetTriggers = self.NESTABLE_TAGS.get(name)\n        isNestable = nestingResetTriggers != None\n        isResetNesting = self.RESET_NESTING_TAGS.has_key(name)\n        popTo = None\n        inclusive = True\n        for i in range(len(self.tagStack)-1, 0, -1):\n            p = self.tagStack[i]\n            if (not p or p.name == name) and not isNestable:\n                #Non-nestable tags get popped to the top or to their\n                #last occurance.\n                popTo = name\n                break\n            if (nestingResetTriggers != None\n                and p.name in nestingResetTriggers) \\\n                or (nestingResetTriggers == None and isResetNesting\n                    and self.RESET_NESTING_TAGS.has_key(p.name)):\n\n                #If we encounter one of the nesting reset triggers\n                #peculiar to this tag, or we encounter another tag\n                #that causes nesting to reset, pop up to but not\n                #including that tag.\n                popTo = p.name\n                inclusive = False\n                break\n            p = p.parent\n        if popTo:\n            self._popToTag(popTo, inclusive)","function_tokens":["def","_smartPop","(","self",",","name",")",":","nestingResetTriggers","=","self",".","NESTABLE_TAGS",".","get","(","name",")","isNestable","=","nestingResetTriggers","!=","None","isResetNesting","=","self",".","RESET_NESTING_TAGS",".","has_key","(","name",")","popTo","=","None","inclusive","=","True","for","i","in","range","(","len","(","self",".","tagStack",")","-","1",",","0",",","-","1",")",":","p","=","self",".","tagStack","[","i","]","if","(","not","p","or","p",".","name","==","name",")","and","not","isNestable",":","#Non-nestable tags get popped to the top or to their","#last occurance.","popTo","=","name","break","if","(","nestingResetTriggers","!=","None","and","p",".","name","in","nestingResetTriggers",")","or","(","nestingResetTriggers","==","None","and","isResetNesting","and","self",".","RESET_NESTING_TAGS",".","has_key","(","p",".","name",")",")",":","#If we encounter one of the nesting reset triggers","#peculiar to this tag, or we encounter another tag","#that causes nesting to reset, pop up to but not","#including that tag.","popTo","=","p",".","name","inclusive","=","False","break","p","=","p",".","parent","if","popTo",":","self",".","_popToTag","(","popTo",",","inclusive",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1232-L1276"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup._toStringSubclass","parameters":"(self, text, subclass)","argument_list":"","return_statement":"","docstring":"Adds a certain piece of text to the tree as a NavigableString\n        subclass.","docstring_summary":"Adds a certain piece of text to the tree as a NavigableString\n        subclass.","docstring_tokens":["Adds","a","certain","piece","of","text","to","the","tree","as","a","NavigableString","subclass","."],"function":"def _toStringSubclass(self, text, subclass):\n        \"\"\"Adds a certain piece of text to the tree as a NavigableString\n        subclass.\"\"\"\n        self.endData()\n        self.handle_data(text)\n        self.endData(subclass)","function_tokens":["def","_toStringSubclass","(","self",",","text",",","subclass",")",":","self",".","endData","(",")","self",".","handle_data","(","text",")","self",".","endData","(","subclass",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1324-L1329"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.handle_pi","parameters":"(self, text)","argument_list":"","return_statement":"","docstring":"Handle a processing instruction as a ProcessingInstruction\n        object, possibly one with a %SOUP-ENCODING% slot into which an\n        encoding will be plugged later.","docstring_summary":"Handle a processing instruction as a ProcessingInstruction\n        object, possibly one with a %SOUP-ENCODING% slot into which an\n        encoding will be plugged later.","docstring_tokens":["Handle","a","processing","instruction","as","a","ProcessingInstruction","object","possibly","one","with","a","%SOUP","-","ENCODING%","slot","into","which","an","encoding","will","be","plugged","later","."],"function":"def handle_pi(self, text):\n        \"\"\"Handle a processing instruction as a ProcessingInstruction\n        object, possibly one with a %SOUP-ENCODING% slot into which an\n        encoding will be plugged later.\"\"\"\n        if text[:3] == \"xml\":\n            text = u\"xml version='1.0' encoding='%SOUP-ENCODING%'\"\n        self._toStringSubclass(text, ProcessingInstruction)","function_tokens":["def","handle_pi","(","self",",","text",")",":","if","text","[",":","3","]","==","\"xml\"",":","text","=","u\"xml version='1.0' encoding='%SOUP-ENCODING%'\"","self",".","_toStringSubclass","(","text",",","ProcessingInstruction",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1331-L1337"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.handle_comment","parameters":"(self, text)","argument_list":"","return_statement":"","docstring":"Handle comments as Comment objects.","docstring_summary":"Handle comments as Comment objects.","docstring_tokens":["Handle","comments","as","Comment","objects","."],"function":"def handle_comment(self, text):\n        \"Handle comments as Comment objects.\"\n        self._toStringSubclass(text, Comment)","function_tokens":["def","handle_comment","(","self",",","text",")",":","self",".","_toStringSubclass","(","text",",","Comment",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1339-L1341"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.handle_charref","parameters":"(self, ref)","argument_list":"","return_statement":"","docstring":"Handle character references as data.","docstring_summary":"Handle character references as data.","docstring_tokens":["Handle","character","references","as","data","."],"function":"def handle_charref(self, ref):\n        \"Handle character references as data.\"\n        if self.convertEntities:\n            data = unichr(int(ref))\n        else:\n            data = '&#%s;' % ref\n        self.handle_data(data)","function_tokens":["def","handle_charref","(","self",",","ref",")",":","if","self",".","convertEntities",":","data","=","unichr","(","int","(","ref",")",")","else",":","data","=","'&#%s;'","%","ref","self",".","handle_data","(","data",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1343-L1349"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.handle_entityref","parameters":"(self, ref)","argument_list":"","return_statement":"","docstring":"Handle entity references as data, possibly converting known\n        HTML and\/or XML entity references to the corresponding Unicode\n        characters.","docstring_summary":"Handle entity references as data, possibly converting known\n        HTML and\/or XML entity references to the corresponding Unicode\n        characters.","docstring_tokens":["Handle","entity","references","as","data","possibly","converting","known","HTML","and","\/","or","XML","entity","references","to","the","corresponding","Unicode","characters","."],"function":"def handle_entityref(self, ref):\n        \"\"\"Handle entity references as data, possibly converting known\n        HTML and\/or XML entity references to the corresponding Unicode\n        characters.\"\"\"\n        data = None\n        if self.convertHTMLEntities:\n            try:\n                data = unichr(name2codepoint[ref])\n            except KeyError:\n                pass\n\n        if not data and self.convertXMLEntities:\n                data = self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref)\n\n        if not data and self.convertHTMLEntities and \\\n            not self.XML_ENTITIES_TO_SPECIAL_CHARS.get(ref):\n                # TODO: We've got a problem here. We're told this is\n                # an entity reference, but it's not an XML entity\n                # reference or an HTML entity reference. Nonetheless,\n                # the logical thing to do is to pass it through as an\n                # unrecognized entity reference.\n                #\n                # Except: when the input is \"&carol;\" this function\n                # will be called with input \"carol\". When the input is\n                # \"AT&T\", this function will be called with input\n                # \"T\". We have no way of knowing whether a semicolon\n                # was present originally, so we don't know whether\n                # this is an unknown entity or just a misplaced\n                # ampersand.\n                #\n                # The more common case is a misplaced ampersand, so I\n                # escape the ampersand and omit the trailing semicolon.\n                data = \"&amp;%s\" % ref\n        if not data:\n            # This case is different from the one above, because we\n            # haven't already gone through a supposedly comprehensive\n            # mapping of entities to Unicode characters. We might not\n            # have gone through any mapping at all. So the chances are\n            # very high that this is a real entity, and not a\n            # misplaced ampersand.\n            data = \"&%s;\" % ref\n        self.handle_data(data)","function_tokens":["def","handle_entityref","(","self",",","ref",")",":","data","=","None","if","self",".","convertHTMLEntities",":","try",":","data","=","unichr","(","name2codepoint","[","ref","]",")","except","KeyError",":","pass","if","not","data","and","self",".","convertXMLEntities",":","data","=","self",".","XML_ENTITIES_TO_SPECIAL_CHARS",".","get","(","ref",")","if","not","data","and","self",".","convertHTMLEntities","and","not","self",".","XML_ENTITIES_TO_SPECIAL_CHARS",".","get","(","ref",")",":","# TODO: We've got a problem here. We're told this is","# an entity reference, but it's not an XML entity","# reference or an HTML entity reference. Nonetheless,","# the logical thing to do is to pass it through as an","# unrecognized entity reference.","#","# Except: when the input is \"&carol;\" this function","# will be called with input \"carol\". When the input is","# \"AT&T\", this function will be called with input","# \"T\". We have no way of knowing whether a semicolon","# was present originally, so we don't know whether","# this is an unknown entity or just a misplaced","# ampersand.","#","# The more common case is a misplaced ampersand, so I","# escape the ampersand and omit the trailing semicolon.","data","=","\"&amp;%s\"","%","ref","if","not","data",":","# This case is different from the one above, because we","# haven't already gone through a supposedly comprehensive","# mapping of entities to Unicode characters. We might not","# have gone through any mapping at all. So the chances are","# very high that this is a real entity, and not a","# misplaced ampersand.","data","=","\"&%s;\"","%","ref","self",".","handle_data","(","data",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1351-L1392"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.handle_decl","parameters":"(self, data)","argument_list":"","return_statement":"","docstring":"Handle DOCTYPEs and the like as Declaration objects.","docstring_summary":"Handle DOCTYPEs and the like as Declaration objects.","docstring_tokens":["Handle","DOCTYPEs","and","the","like","as","Declaration","objects","."],"function":"def handle_decl(self, data):\n        \"Handle DOCTYPEs and the like as Declaration objects.\"\n        self._toStringSubclass(data, Declaration)","function_tokens":["def","handle_decl","(","self",",","data",")",":","self",".","_toStringSubclass","(","data",",","Declaration",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1394-L1396"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulStoneSoup.parse_declaration","parameters":"(self, i)","argument_list":"","return_statement":"return j","docstring":"Treat a bogus SGML declaration as raw data. Treat a CDATA\n        declaration as a CData object.","docstring_summary":"Treat a bogus SGML declaration as raw data. Treat a CDATA\n        declaration as a CData object.","docstring_tokens":["Treat","a","bogus","SGML","declaration","as","raw","data",".","Treat","a","CDATA","declaration","as","a","CData","object","."],"function":"def parse_declaration(self, i):\n        \"\"\"Treat a bogus SGML declaration as raw data. Treat a CDATA\n        declaration as a CData object.\"\"\"\n        j = None\n        if self.rawdata[i:i+9] == '<![CDATA[':\n             k = self.rawdata.find(']]>', i)\n             if k == -1:\n                 k = len(self.rawdata)\n             data = self.rawdata[i+9:k]\n             j = k+3\n             self._toStringSubclass(data, CData)\n        else:\n            try:\n                j = SGMLParser.parse_declaration(self, i)\n            except SGMLParseError:\n                toHandle = self.rawdata[i:]\n                self.handle_data(toHandle)\n                j = i + len(toHandle)\n        return j","function_tokens":["def","parse_declaration","(","self",",","i",")",":","j","=","None","if","self",".","rawdata","[","i",":","i","+","9","]","==","'<![CDATA['",":","k","=","self",".","rawdata",".","find","(","']]>'",",","i",")","if","k","==","-","1",":","k","=","len","(","self",".","rawdata",")","data","=","self",".","rawdata","[","i","+","9",":","k","]","j","=","k","+","3","self",".","_toStringSubclass","(","data",",","CData",")","else",":","try",":","j","=","SGMLParser",".","parse_declaration","(","self",",","i",")","except","SGMLParseError",":","toHandle","=","self",".","rawdata","[","i",":","]","self",".","handle_data","(","toHandle",")","j","=","i","+","len","(","toHandle",")","return","j"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1398-L1416"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"BeautifulSoup.start_meta","parameters":"(self, attrs)","argument_list":"","return_statement":"","docstring":"Beautiful Soup can detect a charset included in a META tag,\n        try to convert the document to that charset, and re-parse the\n        document from the beginning.","docstring_summary":"Beautiful Soup can detect a charset included in a META tag,\n        try to convert the document to that charset, and re-parse the\n        document from the beginning.","docstring_tokens":["Beautiful","Soup","can","detect","a","charset","included","in","a","META","tag","try","to","convert","the","document","to","that","charset","and","re","-","parse","the","document","from","the","beginning","."],"function":"def start_meta(self, attrs):\n        \"\"\"Beautiful Soup can detect a charset included in a META tag,\n        try to convert the document to that charset, and re-parse the\n        document from the beginning.\"\"\"\n        httpEquiv = None\n        contentType = None\n        contentTypeIndex = None\n        tagNeedsEncodingSubstitution = False\n\n        for i in range(0, len(attrs)):\n            key, value = attrs[i]\n            key = key.lower()\n            if key == 'http-equiv':\n                httpEquiv = value\n            elif key == 'content':\n                contentType = value\n                contentTypeIndex = i\n\n        if httpEquiv and contentType: # It's an interesting meta tag.\n            match = self.CHARSET_RE.search(contentType)\n            if match:\n                if (self.declaredHTMLEncoding is not None or\n                    self.originalEncoding == self.fromEncoding):\n                    # An HTML encoding was sniffed while converting\n                    # the document to Unicode, or an HTML encoding was\n                    # sniffed during a previous pass through the\n                    # document, or an encoding was specified\n                    # explicitly and it worked. Rewrite the meta tag.\n                    def rewrite(match):\n                        return match.group(1) + \"%SOUP-ENCODING%\"\n                    newAttr = self.CHARSET_RE.sub(rewrite, contentType)\n                    attrs[contentTypeIndex] = (attrs[contentTypeIndex][0],\n                                               newAttr)\n                    tagNeedsEncodingSubstitution = True\n                else:\n                    # This is our first pass through the document.\n                    # Go through it again with the encoding information.\n                    newCharset = match.group(3)\n                    if newCharset and newCharset != self.originalEncoding:\n                        self.declaredHTMLEncoding = newCharset\n                        self._feed(self.declaredHTMLEncoding)\n                        raise StopParsing\n                    pass\n        tag = self.unknown_starttag(\"meta\", attrs)\n        if tag and tagNeedsEncodingSubstitution:\n            tag.containsSubstitutions = True","function_tokens":["def","start_meta","(","self",",","attrs",")",":","httpEquiv","=","None","contentType","=","None","contentTypeIndex","=","None","tagNeedsEncodingSubstitution","=","False","for","i","in","range","(","0",",","len","(","attrs",")",")",":","key",",","value","=","attrs","[","i","]","key","=","key",".","lower","(",")","if","key","==","'http-equiv'",":","httpEquiv","=","value","elif","key","==","'content'",":","contentType","=","value","contentTypeIndex","=","i","if","httpEquiv","and","contentType",":","# It's an interesting meta tag.","match","=","self",".","CHARSET_RE",".","search","(","contentType",")","if","match",":","if","(","self",".","declaredHTMLEncoding","is","not","None","or","self",".","originalEncoding","==","self",".","fromEncoding",")",":","# An HTML encoding was sniffed while converting","# the document to Unicode, or an HTML encoding was","# sniffed during a previous pass through the","# document, or an encoding was specified","# explicitly and it worked. Rewrite the meta tag.","def","rewrite","(","match",")",":","return","match",".","group","(","1",")","+","\"%SOUP-ENCODING%\"","newAttr","=","self",".","CHARSET_RE",".","sub","(","rewrite",",","contentType",")","attrs","[","contentTypeIndex","]","=","(","attrs","[","contentTypeIndex","]","[","0","]",",","newAttr",")","tagNeedsEncodingSubstitution","=","True","else",":","# This is our first pass through the document.","# Go through it again with the encoding information.","newCharset","=","match",".","group","(","3",")","if","newCharset","and","newCharset","!=","self",".","originalEncoding",":","self",".","declaredHTMLEncoding","=","newCharset","self",".","_feed","(","self",".","declaredHTMLEncoding",")","raise","StopParsing","pass","tag","=","self",".","unknown_starttag","(","\"meta\"",",","attrs",")","if","tag","and","tagNeedsEncodingSubstitution",":","tag",".","containsSubstitutions","=","True"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1524-L1569"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"UnicodeDammit._subMSChar","parameters":"(self, orig)","argument_list":"","return_statement":"return sub","docstring":"Changes a MS smart quote character to an XML or HTML\n        entity.","docstring_summary":"Changes a MS smart quote character to an XML or HTML\n        entity.","docstring_tokens":["Changes","a","MS","smart","quote","character","to","an","XML","or","HTML","entity","."],"function":"def _subMSChar(self, orig):\n        \"\"\"Changes a MS smart quote character to an XML or HTML\n        entity.\"\"\"\n        sub = self.MS_CHARS.get(orig)\n        if type(sub) == types.TupleType:\n            if self.smartQuotesTo == 'xml':\n                sub = '&#x%s;' % sub[1]\n            else:\n                sub = '&%s;' % sub[0]\n        return sub","function_tokens":["def","_subMSChar","(","self",",","orig",")",":","sub","=","self",".","MS_CHARS",".","get","(","orig",")","if","type","(","sub",")","==","types",".","TupleType",":","if","self",".","smartQuotesTo","==","'xml'",":","sub","=","'&#x%s;'","%","sub","[","1","]","else",":","sub","=","'&%s;'","%","sub","[","0","]","return","sub"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1751-L1760"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"UnicodeDammit._toUnicode","parameters":"(self, data, encoding)","argument_list":"","return_statement":"return newdata","docstring":"Given a string and its encoding, decodes the string into Unicode.\n        %encoding is a string recognized by encodings.aliases","docstring_summary":"Given a string and its encoding, decodes the string into Unicode.\n        %encoding is a string recognized by encodings.aliases","docstring_tokens":["Given","a","string","and","its","encoding","decodes","the","string","into","Unicode",".","%encoding","is","a","string","recognized","by","encodings",".","aliases"],"function":"def _toUnicode(self, data, encoding):\n        '''Given a string and its encoding, decodes the string into Unicode.\n        %encoding is a string recognized by encodings.aliases'''\n\n        # strip Byte Order Mark (if present)\n        if (len(data) >= 4) and (data[:2] == '\\xfe\\xff') \\\n               and (data[2:4] != '\\x00\\x00'):\n            encoding = 'utf-16be'\n            data = data[2:]\n        elif (len(data) >= 4) and (data[:2] == '\\xff\\xfe') \\\n                 and (data[2:4] != '\\x00\\x00'):\n            encoding = 'utf-16le'\n            data = data[2:]\n        elif data[:3] == '\\xef\\xbb\\xbf':\n            encoding = 'utf-8'\n            data = data[3:]\n        elif data[:4] == '\\x00\\x00\\xfe\\xff':\n            encoding = 'utf-32be'\n            data = data[4:]\n        elif data[:4] == '\\xff\\xfe\\x00\\x00':\n            encoding = 'utf-32le'\n            data = data[4:]\n        newdata = unicode(data, encoding)\n        return newdata","function_tokens":["def","_toUnicode","(","self",",","data",",","encoding",")",":","# strip Byte Order Mark (if present)","if","(","len","(","data",")",">=","4",")","and","(","data","[",":","2","]","==","'\\xfe\\xff'",")","and","(","data","[","2",":","4","]","!=","'\\x00\\x00'",")",":","encoding","=","'utf-16be'","data","=","data","[","2",":","]","elif","(","len","(","data",")",">=","4",")","and","(","data","[",":","2","]","==","'\\xff\\xfe'",")","and","(","data","[","2",":","4","]","!=","'\\x00\\x00'",")",":","encoding","=","'utf-16le'","data","=","data","[","2",":","]","elif","data","[",":","3","]","==","'\\xef\\xbb\\xbf'",":","encoding","=","'utf-8'","data","=","data","[","3",":","]","elif","data","[",":","4","]","==","'\\x00\\x00\\xfe\\xff'",":","encoding","=","'utf-32be'","data","=","data","[","4",":","]","elif","data","[",":","4","]","==","'\\xff\\xfe\\x00\\x00'",":","encoding","=","'utf-32le'","data","=","data","[","4",":","]","newdata","=","unicode","(","data",",","encoding",")","return","newdata"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1790-L1813"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/BeautifulSoup.py","language":"python","identifier":"UnicodeDammit._detectEncoding","parameters":"(self, xml_data, isHTML=False)","argument_list":"","return_statement":"return xml_data, xml_encoding, sniffed_xml_encoding","docstring":"Given a document, tries to detect its XML encoding.","docstring_summary":"Given a document, tries to detect its XML encoding.","docstring_tokens":["Given","a","document","tries","to","detect","its","XML","encoding","."],"function":"def _detectEncoding(self, xml_data, isHTML=False):\n        \"\"\"Given a document, tries to detect its XML encoding.\"\"\"\n        xml_encoding = sniffed_xml_encoding = None\n        try:\n            if xml_data[:4] == '\\x4c\\x6f\\xa7\\x94':\n                # EBCDIC\n                xml_data = self._ebcdic_to_ascii(xml_data)\n            elif xml_data[:4] == '\\x00\\x3c\\x00\\x3f':\n                # UTF-16BE\n                sniffed_xml_encoding = 'utf-16be'\n                xml_data = unicode(xml_data, 'utf-16be').encode('utf-8')\n            elif (len(xml_data) >= 4) and (xml_data[:2] == '\\xfe\\xff') \\\n                     and (xml_data[2:4] != '\\x00\\x00'):\n                # UTF-16BE with BOM\n                sniffed_xml_encoding = 'utf-16be'\n                xml_data = unicode(xml_data[2:], 'utf-16be').encode('utf-8')\n            elif xml_data[:4] == '\\x3c\\x00\\x3f\\x00':\n                # UTF-16LE\n                sniffed_xml_encoding = 'utf-16le'\n                xml_data = unicode(xml_data, 'utf-16le').encode('utf-8')\n            elif (len(xml_data) >= 4) and (xml_data[:2] == '\\xff\\xfe') and \\\n                     (xml_data[2:4] != '\\x00\\x00'):\n                # UTF-16LE with BOM\n                sniffed_xml_encoding = 'utf-16le'\n                xml_data = unicode(xml_data[2:], 'utf-16le').encode('utf-8')\n            elif xml_data[:4] == '\\x00\\x00\\x00\\x3c':\n                # UTF-32BE\n                sniffed_xml_encoding = 'utf-32be'\n                xml_data = unicode(xml_data, 'utf-32be').encode('utf-8')\n            elif xml_data[:4] == '\\x3c\\x00\\x00\\x00':\n                # UTF-32LE\n                sniffed_xml_encoding = 'utf-32le'\n                xml_data = unicode(xml_data, 'utf-32le').encode('utf-8')\n            elif xml_data[:4] == '\\x00\\x00\\xfe\\xff':\n                # UTF-32BE with BOM\n                sniffed_xml_encoding = 'utf-32be'\n                xml_data = unicode(xml_data[4:], 'utf-32be').encode('utf-8')\n            elif xml_data[:4] == '\\xff\\xfe\\x00\\x00':\n                # UTF-32LE with BOM\n                sniffed_xml_encoding = 'utf-32le'\n                xml_data = unicode(xml_data[4:], 'utf-32le').encode('utf-8')\n            elif xml_data[:3] == '\\xef\\xbb\\xbf':\n                # UTF-8 with BOM\n                sniffed_xml_encoding = 'utf-8'\n                xml_data = unicode(xml_data[3:], 'utf-8').encode('utf-8')\n            else:\n                sniffed_xml_encoding = 'ascii'\n                pass\n        except:\n            xml_encoding_match = None\n        xml_encoding_match = re.compile(\n            '^<\\?.*encoding=[\\'\"](.*?)[\\'\"].*\\?>').match(xml_data)\n        if not xml_encoding_match and isHTML:\n            regexp = re.compile('<\\s*meta[^>]+charset=([^>]*?)[;\\'\">]', re.I)\n            xml_encoding_match = regexp.search(xml_data)\n        if xml_encoding_match is not None:\n            xml_encoding = xml_encoding_match.groups()[0].lower()\n            if isHTML:\n                self.declaredHTMLEncoding = xml_encoding\n            if sniffed_xml_encoding and \\\n               (xml_encoding in ('iso-10646-ucs-2', 'ucs-2', 'csunicode',\n                                 'iso-10646-ucs-4', 'ucs-4', 'csucs4',\n                                 'utf-16', 'utf-32', 'utf_16', 'utf_32',\n                                 'utf16', 'u16')):\n                xml_encoding = sniffed_xml_encoding\n        return xml_data, xml_encoding, sniffed_xml_encoding","function_tokens":["def","_detectEncoding","(","self",",","xml_data",",","isHTML","=","False",")",":","xml_encoding","=","sniffed_xml_encoding","=","None","try",":","if","xml_data","[",":","4","]","==","'\\x4c\\x6f\\xa7\\x94'",":","# EBCDIC","xml_data","=","self",".","_ebcdic_to_ascii","(","xml_data",")","elif","xml_data","[",":","4","]","==","'\\x00\\x3c\\x00\\x3f'",":","# UTF-16BE","sniffed_xml_encoding","=","'utf-16be'","xml_data","=","unicode","(","xml_data",",","'utf-16be'",")",".","encode","(","'utf-8'",")","elif","(","len","(","xml_data",")",">=","4",")","and","(","xml_data","[",":","2","]","==","'\\xfe\\xff'",")","and","(","xml_data","[","2",":","4","]","!=","'\\x00\\x00'",")",":","# UTF-16BE with BOM","sniffed_xml_encoding","=","'utf-16be'","xml_data","=","unicode","(","xml_data","[","2",":","]",",","'utf-16be'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","4","]","==","'\\x3c\\x00\\x3f\\x00'",":","# UTF-16LE","sniffed_xml_encoding","=","'utf-16le'","xml_data","=","unicode","(","xml_data",",","'utf-16le'",")",".","encode","(","'utf-8'",")","elif","(","len","(","xml_data",")",">=","4",")","and","(","xml_data","[",":","2","]","==","'\\xff\\xfe'",")","and","(","xml_data","[","2",":","4","]","!=","'\\x00\\x00'",")",":","# UTF-16LE with BOM","sniffed_xml_encoding","=","'utf-16le'","xml_data","=","unicode","(","xml_data","[","2",":","]",",","'utf-16le'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","4","]","==","'\\x00\\x00\\x00\\x3c'",":","# UTF-32BE","sniffed_xml_encoding","=","'utf-32be'","xml_data","=","unicode","(","xml_data",",","'utf-32be'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","4","]","==","'\\x3c\\x00\\x00\\x00'",":","# UTF-32LE","sniffed_xml_encoding","=","'utf-32le'","xml_data","=","unicode","(","xml_data",",","'utf-32le'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","4","]","==","'\\x00\\x00\\xfe\\xff'",":","# UTF-32BE with BOM","sniffed_xml_encoding","=","'utf-32be'","xml_data","=","unicode","(","xml_data","[","4",":","]",",","'utf-32be'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","4","]","==","'\\xff\\xfe\\x00\\x00'",":","# UTF-32LE with BOM","sniffed_xml_encoding","=","'utf-32le'","xml_data","=","unicode","(","xml_data","[","4",":","]",",","'utf-32le'",")",".","encode","(","'utf-8'",")","elif","xml_data","[",":","3","]","==","'\\xef\\xbb\\xbf'",":","# UTF-8 with BOM","sniffed_xml_encoding","=","'utf-8'","xml_data","=","unicode","(","xml_data","[","3",":","]",",","'utf-8'",")",".","encode","(","'utf-8'",")","else",":","sniffed_xml_encoding","=","'ascii'","pass","except",":","xml_encoding_match","=","None","xml_encoding_match","=","re",".","compile","(","'^<\\?.*encoding=[\\'\"](.*?)[\\'\"].*\\?>'",")",".","match","(","xml_data",")","if","not","xml_encoding_match","and","isHTML",":","regexp","=","re",".","compile","(","'<\\s*meta[^>]+charset=([^>]*?)[;\\'\">]'",",","re",".","I",")","xml_encoding_match","=","regexp",".","search","(","xml_data",")","if","xml_encoding_match","is","not","None",":","xml_encoding","=","xml_encoding_match",".","groups","(",")","[","0","]",".","lower","(",")","if","isHTML",":","self",".","declaredHTMLEncoding","=","xml_encoding","if","sniffed_xml_encoding","and","(","xml_encoding","in","(","'iso-10646-ucs-2'",",","'ucs-2'",",","'csunicode'",",","'iso-10646-ucs-4'",",","'ucs-4'",",","'csucs4'",",","'utf-16'",",","'utf-32'",",","'utf_16'",",","'utf_32'",",","'utf16'",",","'u16'",")",")",":","xml_encoding","=","sniffed_xml_encoding","return","xml_data",",","xml_encoding",",","sniffed_xml_encoding"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/BeautifulSoup.py#L1815-L1880"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"_in_tag","parameters":"(text, tag)","argument_list":"","return_statement":"return text","docstring":"Extracts text from inside a tag.\n\n    This function extracts the text from inside a given tag.\n    It's useful to get the text between <body><\/body> or\n    <pre><\/pre> when using the validators or the colorizer.","docstring_summary":"Extracts text from inside a tag.","docstring_tokens":["Extracts","text","from","inside","a","tag","."],"function":"def _in_tag(text, tag):\n    \"\"\"Extracts text from inside a tag.\n\n    This function extracts the text from inside a given tag.\n    It's useful to get the text between <body><\/body> or\n    <pre><\/pre> when using the validators or the colorizer.\n    \"\"\"\n    if text.count('<%s' % tag):\n        text = text.split('<%s' % tag, 1)[1]\n        if text.count('>'):\n            text = text.split('>', 1)[1]\n    if text.count('<\/%s' % tag):\n        text = text.split('<\/%s' % tag, 1)[0]\n\n    text = text.strip().replace('\\r\\n', '\\n')\n\n    return text","function_tokens":["def","_in_tag","(","text",",","tag",")",":","if","text",".","count","(","'<%s'","%","tag",")",":","text","=","text",".","split","(","'<%s'","%","tag",",","1",")","[","1","]","if","text",".","count","(","'>'",")",":","text","=","text",".","split","(","'>'",",","1",")","[","1","]","if","text",".","count","(","'<\/%s'","%","tag",")",":","text","=","text",".","split","(","'<\/%s'","%","tag",",","1",")","[","0","]","text","=","text",".","strip","(",")",".","replace","(","'\\r\\n'",",","'\\n'",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L167-L183"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"_debug","parameters":"(s, level=1)","argument_list":"","return_statement":"","docstring":"Outputs debug information to sys.stderr.\n\n    This function outputs debug information if DEBUGLEVEL is\n    higher than a given treshold.","docstring_summary":"Outputs debug information to sys.stderr.","docstring_tokens":["Outputs","debug","information","to","sys",".","stderr","."],"function":"def _debug(s, level=1):\n    \"\"\"Outputs debug information to sys.stderr.\n\n    This function outputs debug information if DEBUGLEVEL is\n    higher than a given treshold.\n    \"\"\"\n    if DEBUGLEVEL >= level: print >> sys.stderr, s","function_tokens":["def","_debug","(","s",",","level","=","1",")",":","if","DEBUGLEVEL",">=","level",":","print",">>","sys",".","stderr",",","s"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L258-L264"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"preg_replace","parameters":"(pattern, replacement, text)","argument_list":"","return_statement":"return p.sub(replacement_func, text)","docstring":"Alternative re.sub that handles empty groups.\n\n    This acts like re.sub, except it replaces empty groups with ''\n    instead of raising an exception.","docstring_summary":"Alternative re.sub that handles empty groups.","docstring_tokens":["Alternative","re",".","sub","that","handles","empty","groups","."],"function":"def preg_replace(pattern, replacement, text):\n    \"\"\"Alternative re.sub that handles empty groups.\n\n    This acts like re.sub, except it replaces empty groups with ''\n    instead of raising an exception.\n    \"\"\"\n\n    def replacement_func(matchobj):\n        counter = 1\n        rc = replacement\n        _debug(matchobj.groups())\n        for matchitem in matchobj.groups():\n            if not matchitem:\n                matchitem = ''\n\n            rc = rc.replace(r'\\%s' % counter, matchitem)\n            counter += 1\n\n        return rc\n        \n    p = re.compile(pattern)\n    _debug(pattern)\n\n    return p.sub(replacement_func, text)","function_tokens":["def","preg_replace","(","pattern",",","replacement",",","text",")",":","def","replacement_func","(","matchobj",")",":","counter","=","1","rc","=","replacement","_debug","(","matchobj",".","groups","(",")",")","for","matchitem","in","matchobj",".","groups","(",")",":","if","not","matchitem",":","matchitem","=","''","rc","=","rc",".","replace","(","r'\\%s'","%","counter",",","matchitem",")","counter","+=","1","return","rc","p","=","re",".","compile","(","pattern",")","_debug","(","pattern",")","return","p",".","sub","(","replacement_func",",","text",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L453-L476"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"html_replace","parameters":"(pattern, replacement, text)","argument_list":"","return_statement":"","docstring":"Replacement outside HTML tags.\n\n    Does a preg_replace only outside HTML tags.","docstring_summary":"Replacement outside HTML tags.","docstring_tokens":["Replacement","outside","HTML","tags","."],"function":"def html_replace(pattern, replacement, text):\n    \"\"\"Replacement outside HTML tags.\n\n    Does a preg_replace only outside HTML tags.\n    \"\"\"\n    # If there is no html, do a simple search and replace.\n    if not re.search(r'''<.*>''', text):\n        return preg_replace(pattern, replacement, text)\n\n    else:\n        lines = []\n        # Else split the text into an array at <>.\n        for line in re.split('(<.*?>)', text):\n            if not re.match('<.*?>', line):\n                line = preg_replace(pattern, replacement, line)\n\n            lines.append(line)\n\n        return ''.join(lines)","function_tokens":["def","html_replace","(","pattern",",","replacement",",","text",")",":","# If there is no html, do a simple search and replace.","if","not","re",".","search","(","r'''<.*>'''",",","text",")",":","return","preg_replace","(","pattern",",","replacement",",","text",")","else",":","lines","=","[","]","# Else split the text into an array at <>.","for","line","in","re",".","split","(","'(<.*?>)'",",","text",")",":","if","not","re",".","match","(","'<.*?>'",",","line",")",":","line","=","preg_replace","(","pattern",",","replacement",",","line",")","lines",".","append","(","line",")","return","''",".","join","(","lines",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L479-L497"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"textile","parameters":"(text, **args)","argument_list":"","return_statement":"return Textiler(text).process(**args)","docstring":"This is Textile.\n\n    Generates XHTML from a simple markup developed by Dean Allen.\n\n    This function should be called like this:\n    \n        textile(text, head_offset=0, validate=0, sanitize=0,\n                encoding='latin-1', output='ASCII')","docstring_summary":"This is Textile.","docstring_tokens":["This","is","Textile","."],"function":"def textile(text, **args):\n    \"\"\"This is Textile.\n\n    Generates XHTML from a simple markup developed by Dean Allen.\n\n    This function should be called like this:\n    \n        textile(text, head_offset=0, validate=0, sanitize=0,\n                encoding='latin-1', output='ASCII')\n    \"\"\"\n    return Textiler(text).process(**args)","function_tokens":["def","textile","(","text",",","*","*","args",")",":","return","Textiler","(","text",")",".","process","(","*","*","args",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2859-L2869"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"_BaseHTMLProcessor.output","parameters":"(self)","argument_list":"","return_statement":"return \"\".join(self.pieces)","docstring":"Return processed HTML as a single string","docstring_summary":"Return processed HTML as a single string","docstring_tokens":["Return","processed","HTML","as","a","single","string"],"function":"def output(self):\n        \"\"\"Return processed HTML as a single string\"\"\"\n        return \"\".join(self.pieces)","function_tokens":["def","output","(","self",")",":","return","\"\"",".","join","(","self",".","pieces",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L569-L571"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.__init__","parameters":"(self, text='')","argument_list":"","return_statement":"","docstring":"Instantiate the class, passing the text to be formatted.\n            \n        Here we pre-process the text and collect all the link\n        lookups for later.","docstring_summary":"Instantiate the class, passing the text to be formatted.\n            \n        Here we pre-process the text and collect all the link\n        lookups for later.","docstring_tokens":["Instantiate","the","class","passing","the","text","to","be","formatted",".","Here","we","pre","-","process","the","text","and","collect","all","the","link","lookups","for","later","."],"function":"def __init__(self, text=''):\n        \"\"\"Instantiate the class, passing the text to be formatted.\n            \n        Here we pre-process the text and collect all the link\n        lookups for later.\n        \"\"\"\n        self.text = text\n\n        # Basic regular expressions.\n        self.res = res\n\n        # Smart searches.\n        self.searches = {}\n        self.searches['imdb']   = 'http:\/\/www.imdb.com\/Find?for=%s'\n        self.searches['google'] = 'http:\/\/www.google.com\/search?q=%s'\n        self.searches['python'] = 'http:\/\/www.python.org\/doc\/current\/lib\/module-%s.html'\n        if amazon_associate_id:\n            self.searches['isbn']   = ''.join(['http:\/\/', AMAZON, '\/exec\/obidos\/ASIN\/%s\/', amazon_associate_id])\n            self.searches['amazon'] = ''.join(['http:\/\/', AMAZON, '\/exec\/obidos\/external-search?mode=blended&keyword=%s&tag=', amazon_associate_id])\n        else:\n            self.searches['isbn']   = ''.join(['http:\/\/', AMAZON, '\/exec\/obidos\/ASIN\/%s'])\n            self.searches['amazon'] = ''.join(['http:\/\/', AMAZON, '\/exec\/obidos\/external-search?mode=blended&keyword=%s'])\n\n        # These are the blocks we know.\n        self.signatures = [\n                           # Paragraph.\n                           (r'''^p                       # Paragraph signature\n                                %(battr)s                # Paragraph attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended paragraph denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.paragraph),\n   \n                           # Pre-formatted text.\n                           (r'''^pre                     # Pre signature\n                                %(battr)s                # Pre attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended pre denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.pre),\n   \n                           # Block code.\n                           (r'''^bc                      # Blockcode signature\n                                %(battr)s                # Blockcode attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockcode denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.bc),\n   \n                           # Blockquote.\n                           (r'''^bq                      # Blockquote signature\n                                %(battr)s                # Blockquote attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockquote denoted by a second dot\n                                (:(?P<cite>              # Optional cite attribute\n                                (                        #\n                                    %(url)s              #     URL\n                                |   \"[\\w]+(?:\\s[\\w]+)*\"  #     \"Name inside quotes\"\n                                ))                       #\n                                )?                       #\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.blockquote),\n   \n                           # Header.\n                           (r'''^h                       # Header signature\n                                (?P<header>\\d)           # Header number\n                                %(battr)s                # Header attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended header denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.header),\n   \n                           # Footnote.\n                           (r'''^fn                      # Footnote signature\n                                (?P<footnote>[\\d]+)      # Footnote number\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended footnote denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''', self.footnote),\n   \n                           # Definition list.\n                           (r'''^dl                      # Definition list signature\n                                %(battr)s                # Definition list attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended definition list denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.dl),\n                           \n                           # Ordered list (attributes to first <li>).\n                           (r'''^%(olattr)s              # Ordered list attributes\n                                \\#                       # Ordered list signature\n                                %(liattr)s               # List item attributes\n                                (?P<dot>\\.)?             # .\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.ol),\n   \n                           # Unordered list (attributes to first <li>).\n                           (r'''^%(olattr)s              # Unrdered list attributes\n                                \\*                       # Unordered list signature\n                                %(liattr)s               # Unordered list attributes\n                                (?P<dot>\\.)?             # .\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.ul),\n   \n                           # Escaped text.\n                           (r'''^==?(?P<text>.*?)(==)?$  # Escaped text\n                             ''', self.escape),\n   \n                           (r'''^(?P<text><.*)$          # XHTML tag\n                             ''', self.escape),\n   \n                           # itex code.\n                           (r'''^(?P<text>               # itex code\n                                \\\\\\[                     # starts with \\[\n                                .*?                      # complicated mathematical equations go here\n                                \\\\\\])                    # ends with \\]\n                             ''', self.itex),\n   \n                           # Tables.\n                           (r'''^table                   # Table signature\n                                %(tattr)s                # Table attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockcode denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             ''' % self.res, self.table),\n                           \n                           # Simple tables.\n                           (r'''^(?P<text>\n                                \\|\n                                .*)\n                             ''', self.table),\n   \n                           # About.\n                           (r'''^(?P<text>tell\\sme\\sabout\\stextile\\.)$''', self.about),\n                          ]","function_tokens":["def","__init__","(","self",",","text","=","''",")",":","self",".","text","=","text","# Basic regular expressions.","self",".","res","=","res","# Smart searches.","self",".","searches","=","{","}","self",".","searches","[","'imdb'","]","=","'http:\/\/www.imdb.com\/Find?for=%s'","self",".","searches","[","'google'","]","=","'http:\/\/www.google.com\/search?q=%s'","self",".","searches","[","'python'","]","=","'http:\/\/www.python.org\/doc\/current\/lib\/module-%s.html'","if","amazon_associate_id",":","self",".","searches","[","'isbn'","]","=","''",".","join","(","[","'http:\/\/'",",","AMAZON",",","'\/exec\/obidos\/ASIN\/%s\/'",",","amazon_associate_id","]",")","self",".","searches","[","'amazon'","]","=","''",".","join","(","[","'http:\/\/'",",","AMAZON",",","'\/exec\/obidos\/external-search?mode=blended&keyword=%s&tag='",",","amazon_associate_id","]",")","else",":","self",".","searches","[","'isbn'","]","=","''",".","join","(","[","'http:\/\/'",",","AMAZON",",","'\/exec\/obidos\/ASIN\/%s'","]",")","self",".","searches","[","'amazon'","]","=","''",".","join","(","[","'http:\/\/'",",","AMAZON",",","'\/exec\/obidos\/external-search?mode=blended&keyword=%s'","]",")","# These are the blocks we know.","self",".","signatures","=","[","# Paragraph.","(","r'''^p                       # Paragraph signature\n                                %(battr)s                # Paragraph attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended paragraph denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","paragraph",")",",","# Pre-formatted text.","(","r'''^pre                     # Pre signature\n                                %(battr)s                # Pre attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended pre denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","pre",")",",","# Block code.","(","r'''^bc                      # Blockcode signature\n                                %(battr)s                # Blockcode attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockcode denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","bc",")",",","# Blockquote.","(","r'''^bq                      # Blockquote signature\n                                %(battr)s                # Blockquote attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockquote denoted by a second dot\n                                (:(?P<cite>              # Optional cite attribute\n                                (                        #\n                                    %(url)s              #     URL\n                                |   \"[\\w]+(?:\\s[\\w]+)*\"  #     \"Name inside quotes\"\n                                ))                       #\n                                )?                       #\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","blockquote",")",",","# Header.","(","r'''^h                       # Header signature\n                                (?P<header>\\d)           # Header number\n                                %(battr)s                # Header attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended header denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","header",")",",","# Footnote.","(","r'''^fn                      # Footnote signature\n                                (?P<footnote>[\\d]+)      # Footnote number\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended footnote denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''",",","self",".","footnote",")",",","# Definition list.","(","r'''^dl                      # Definition list signature\n                                %(battr)s                # Definition list attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended definition list denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","dl",")",",","# Ordered list (attributes to first <li>).","(","r'''^%(olattr)s              # Ordered list attributes\n                                \\#                       # Ordered list signature\n                                %(liattr)s               # List item attributes\n                                (?P<dot>\\.)?             # .\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","ol",")",",","# Unordered list (attributes to first <li>).","(","r'''^%(olattr)s              # Unrdered list attributes\n                                \\*                       # Unordered list signature\n                                %(liattr)s               # Unordered list attributes\n                                (?P<dot>\\.)?             # .\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","ul",")",",","# Escaped text.","(","r'''^==?(?P<text>.*?)(==)?$  # Escaped text\n                             '''",",","self",".","escape",")",",","(","r'''^(?P<text><.*)$          # XHTML tag\n                             '''",",","self",".","escape",")",",","# itex code.","(","r'''^(?P<text>               # itex code\n                                \\\\\\[                     # starts with \\[\n                                .*?                      # complicated mathematical equations go here\n                                \\\\\\])                    # ends with \\]\n                             '''",",","self",".","itex",")",",","# Tables.","(","r'''^table                   # Table signature\n                                %(tattr)s                # Table attributes\n                                (?P<dot>\\.)              # .\n                                (?P<extend>\\.)?          # Extended blockcode denoted by a second dot\n                                \\s                       # whitespace\n                                (?P<text>.*)             # text\n                             '''","%","self",".","res",",","self",".","table",")",",","# Simple tables.","(","r'''^(?P<text>\n                                \\|\n                                .*)\n                             '''",",","self",".","table",")",",","# About.","(","r'''^(?P<text>tell\\sme\\sabout\\stextile\\.)$'''",",","self",".","about",")",",","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L640-L784"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.preprocess","parameters":"(self)","argument_list":"","return_statement":"","docstring":"Pre-processing of the text.\n\n        Remove whitespace, fix carriage returns.","docstring_summary":"Pre-processing of the text.","docstring_tokens":["Pre","-","processing","of","the","text","."],"function":"def preprocess(self):\n        \"\"\"Pre-processing of the text.\n\n        Remove whitespace, fix carriage returns.\n        \"\"\"\n        # Remove whitespace.\n        self.text = self.text.strip()\n\n        # Zap carriage returns.\n        self.text = self.text.replace(\"\\r\\n\", \"\\n\")\n        self.text = self.text.replace(\"\\r\", \"\\n\")\n\n        # Minor sanitizing.\n        self.text = self.sanitize(self.text)","function_tokens":["def","preprocess","(","self",")",":","# Remove whitespace.","self",".","text","=","self",".","text",".","strip","(",")","# Zap carriage returns.","self",".","text","=","self",".","text",".","replace","(","\"\\r\\n\"",",","\"\\n\"",")","self",".","text","=","self",".","text",".","replace","(","\"\\r\"",",","\"\\n\"",")","# Minor sanitizing.","self",".","text","=","self",".","sanitize","(","self",".","text",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L787-L800"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.grab_links","parameters":"(self)","argument_list":"","return_statement":"return links","docstring":"Grab link lookups.\n\n        Check the text for link lookups, store them in a \n        dictionary, and clean them up.","docstring_summary":"Grab link lookups.","docstring_tokens":["Grab","link","lookups","."],"function":"def grab_links(self):\n        \"\"\"Grab link lookups.\n\n        Check the text for link lookups, store them in a \n        dictionary, and clean them up.\n        \"\"\"\n        # Grab links like this: '[id]example.com'\n        links = {}\n        p = re.compile(r'''(?:^|\\n)\\[([\\w]+?)\\](%(url)s)(?:$|\\n)''' % self.res, re.VERBOSE)\n        for key, link in p.findall(self.text):\n            links[key] = link\n\n        # And clear them from the text.\n        self.text = p.sub('', self.text)\n\n        return links","function_tokens":["def","grab_links","(","self",")",":","# Grab links like this: '[id]example.com'","links","=","{","}","p","=","re",".","compile","(","r'''(?:^|\\n)\\[([\\w]+?)\\](%(url)s)(?:$|\\n)'''","%","self",".","res",",","re",".","VERBOSE",")","for","key",",","link","in","p",".","findall","(","self",".","text",")",":","links","[","key","]","=","link","# And clear them from the text.","self",".","text","=","p",".","sub","(","''",",","self",".","text",")","return","links"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L803-L818"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.process","parameters":"(self, head_offset=HEAD_OFFSET, validate=VALIDATE, sanitize=SANITIZE, output=OUTPUT, encoding=ENCODING)","argument_list":"","return_statement":"return text","docstring":"Process the text.\n\n        Here we actually process the text, splitting the text in\n        blocks and applying the corresponding function to each\n        one of them.","docstring_summary":"Process the text.","docstring_tokens":["Process","the","text","."],"function":"def process(self, head_offset=HEAD_OFFSET, validate=VALIDATE, sanitize=SANITIZE, output=OUTPUT, encoding=ENCODING):\n        \"\"\"Process the text.\n\n        Here we actually process the text, splitting the text in\n        blocks and applying the corresponding function to each\n        one of them.\n        \"\"\"\n        # Basic global changes.\n        self.preprocess()\n\n        # Grab lookup links and clean them from the text.\n        self._links = self.grab_links()\n\n        # Offset for the headers.\n        self.head_offset = head_offset\n\n        # Process each block.\n        self.blocks = self.split_text()\n\n        text = []\n        for [function, captures] in self.blocks:\n            text.append(function(**captures))\n\n        text = '\\n\\n'.join(text)\n\n        # Add titles to footnotes.\n        text = self.footnotes(text)\n\n        # Convert to desired output.\n        text = unicode(text, encoding)\n        text = text.encode(output, 'xmlcharrefreplace')\n\n        # Sanitize?\n        if sanitize:\n            p = _HTMLSanitizer()\n            p.feed(text)\n            text = p.output()\n\n        # Validate output.\n        if _tidy and validate:\n            text = _tidy(text)\n\n        return text","function_tokens":["def","process","(","self",",","head_offset","=","HEAD_OFFSET",",","validate","=","VALIDATE",",","sanitize","=","SANITIZE",",","output","=","OUTPUT",",","encoding","=","ENCODING",")",":","# Basic global changes.","self",".","preprocess","(",")","# Grab lookup links and clean them from the text.","self",".","_links","=","self",".","grab_links","(",")","# Offset for the headers.","self",".","head_offset","=","head_offset","# Process each block.","self",".","blocks","=","self",".","split_text","(",")","text","=","[","]","for","[","function",",","captures","]","in","self",".","blocks",":","text",".","append","(","function","(","*","*","captures",")",")","text","=","'\\n\\n'",".","join","(","text",")","# Add titles to footnotes.","text","=","self",".","footnotes","(","text",")","# Convert to desired output.","text","=","unicode","(","text",",","encoding",")","text","=","text",".","encode","(","output",",","'xmlcharrefreplace'",")","# Sanitize?","if","sanitize",":","p","=","_HTMLSanitizer","(",")","p",".","feed","(","text",")","text","=","p",".","output","(",")","# Validate output.","if","_tidy","and","validate",":","text","=","_tidy","(","text",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L821-L863"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.sanitize","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Fix single tags.\n\n        Fix tags like <img \/>, <br \/> and <hr \/>.\n\n        ---\n        h1. Sanitizing\n\n        Textile can help you generate valid XHTML(eXtensible HyperText Markup Language).\n        It will fix any single tags that are not properly closed, like\n        @<img \/>@, @<br \/>@ and @<hr \/>@.\n\n        If you have \"mx.Tidy\":http:\/\/www.egenix.com\/files\/python\/mxTidy.html\n        and\/or \"&micro;TidyLib\":http:\/\/utidylib.sourceforge.net\/ installed,\n        it also can optionally validade the generated code with these wrappers\n        to ensure 100% valid XHTML(eXtensible HyperText Markup Language).","docstring_summary":"Fix single tags.","docstring_tokens":["Fix","single","tags","."],"function":"def sanitize(self, text):\n        \"\"\"Fix single tags.\n\n        Fix tags like <img \/>, <br \/> and <hr \/>.\n\n        ---\n        h1. Sanitizing\n\n        Textile can help you generate valid XHTML(eXtensible HyperText Markup Language).\n        It will fix any single tags that are not properly closed, like\n        @<img \/>@, @<br \/>@ and @<hr \/>@.\n\n        If you have \"mx.Tidy\":http:\/\/www.egenix.com\/files\/python\/mxTidy.html\n        and\/or \"&micro;TidyLib\":http:\/\/utidylib.sourceforge.net\/ installed,\n        it also can optionally validade the generated code with these wrappers\n        to ensure 100% valid XHTML(eXtensible HyperText Markup Language).\n        \"\"\"\n        # Fix single tags like <img \/> and <br \/>.\n        text = preg_replace(r'''<(img|br|hr)(.*?)(?:\\s*\/?\\s*)?>''', r'''<\\1\\2 \/>''', text)\n\n        # Remove ampersands.\n        text = preg_replace(r'''&(?!#?[xX]?(?:[0-9a-fA-F]+|\\w{1,8});)''', r'''&amp;''', text)\n\n        return text","function_tokens":["def","sanitize","(","self",",","text",")",":","# Fix single tags like <img \/> and <br \/>.","text","=","preg_replace","(","r'''<(img|br|hr)(.*?)(?:\\s*\/?\\s*)?>'''",",","r'''<\\1\\2 \/>'''",",","text",")","# Remove ampersands.","text","=","preg_replace","(","r'''&(?!#?[xX]?(?:[0-9a-fA-F]+|\\w{1,8});)'''",",","r'''&amp;'''",",","text",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L866-L889"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.split_text","parameters":"(self)","argument_list":"","return_statement":"return output","docstring":"Process the blocks from the text.\n\n        Split the blocks according to the signatures, join extended\n        blocks and associate each one of them with a function to\n        process them.\n\n        ---\n        h1. Blocks\n\n        Textile process your text by dividing it in blocks. Each block\n        is identified by a signature and separated from other blocks by\n        an empty line.\n\n        All signatures should end with a period followed by a space. A\n        header @<h1><\/h1>@ can be done this way:\n\n        pre. h1. This is a header 1.\n\n        Blocks may continue for multiple paragraphs of text. If you want\n        a block signature to stay \"active\", use two periods after the\n        signature instead of one. For example:\n\n        pre.. bq.. This is paragraph one of a block quote.\n\n        This is paragraph two of a block quote.\n\n        =p. Now we're back to a regular paragraph.\n\n        p. Becomes:\n        \n        pre.. <blockquote>\n        <p>This is paragraph one of a block quote.<\/p>\n\n        <p>This is paragraph two of a block quote.<\/p>\n        <\/blockquote>\n\n        <p>Now we&#8217;re back to a regular paragraph.<\/p>\n\n        p. The blocks can be customised by adding parameters between the\n        signature and the period. These include:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule.\n        [ll]:A language identifier (for a \"lang\" attribute).\n        (class) or (#id) or (class#id):For CSS(Cascading Style Sheets) class and id attributes.\n        &gt;, &lt;, =, &lt;&gt;:Modifier characters for alignment. Right-justification, left-justification, centered, and full-justification. The paragraph will also receive the class names \"right\", \"left\", \"center\" and \"justify\", respectively.\n        ( (one or more):Adds padding on the left. 1em per \"(\" character is applied. When combined with the align-left or align-right modifier, it makes the block float. \n        ) (one or more):Adds padding on the right. 1em per \")\" character is applied. When combined with the align-left or align-right modifier, it makes the block float.\n\n        Here's an overloaded example:\n\n        pre. p(())>(class#id)[en]{color:red}. A simple paragraph.\n\n        Becomes:\n\n        pre. <p lang=\"en\" style=\"color:red;padding-left:2em;padding-right:2em;float:right;\" class=\"class right\" id=\"id\">A simple paragraph.<\/p>","docstring_summary":"Process the blocks from the text.","docstring_tokens":["Process","the","blocks","from","the","text","."],"function":"def split_text(self):\n        \"\"\"Process the blocks from the text.\n\n        Split the blocks according to the signatures, join extended\n        blocks and associate each one of them with a function to\n        process them.\n\n        ---\n        h1. Blocks\n\n        Textile process your text by dividing it in blocks. Each block\n        is identified by a signature and separated from other blocks by\n        an empty line.\n\n        All signatures should end with a period followed by a space. A\n        header @<h1><\/h1>@ can be done this way:\n\n        pre. h1. This is a header 1.\n\n        Blocks may continue for multiple paragraphs of text. If you want\n        a block signature to stay \"active\", use two periods after the\n        signature instead of one. For example:\n\n        pre.. bq.. This is paragraph one of a block quote.\n\n        This is paragraph two of a block quote.\n\n        =p. Now we're back to a regular paragraph.\n\n        p. Becomes:\n        \n        pre.. <blockquote>\n        <p>This is paragraph one of a block quote.<\/p>\n\n        <p>This is paragraph two of a block quote.<\/p>\n        <\/blockquote>\n\n        <p>Now we&#8217;re back to a regular paragraph.<\/p>\n\n        p. The blocks can be customised by adding parameters between the\n        signature and the period. These include:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule.\n        [ll]:A language identifier (for a \"lang\" attribute).\n        (class) or (#id) or (class#id):For CSS(Cascading Style Sheets) class and id attributes.\n        &gt;, &lt;, =, &lt;&gt;:Modifier characters for alignment. Right-justification, left-justification, centered, and full-justification. The paragraph will also receive the class names \"right\", \"left\", \"center\" and \"justify\", respectively.\n        ( (one or more):Adds padding on the left. 1em per \"(\" character is applied. When combined with the align-left or align-right modifier, it makes the block float. \n        ) (one or more):Adds padding on the right. 1em per \")\" character is applied. When combined with the align-left or align-right modifier, it makes the block float.\n\n        Here's an overloaded example:\n\n        pre. p(())>(class#id)[en]{color:red}. A simple paragraph.\n\n        Becomes:\n\n        pre. <p lang=\"en\" style=\"color:red;padding-left:2em;padding-right:2em;float:right;\" class=\"class right\" id=\"id\">A simple paragraph.<\/p>\n        \"\"\"\n        # Clear signature.\n        clear_sig = r'''^clear(?P<alignment>[<>])?\\.$'''\n        clear = None\n\n        extending  = 0\n\n        # We capture the \\n's because they are important inside \"pre..\".\n        blocks = re.split(r'''((\\n\\s*){2,})''', self.text)\n        output = []\n        for block in blocks:\n            # Check for the clear signature.\n            m = re.match(clear_sig, block)\n            if m:\n                clear = m.group('alignment')\n                if clear:\n                    clear = {'<': 'clear:left;', '>': 'clear:right;'}[clear]\n                else:\n                    clear = 'clear:both;'\n\n            else:\n                # Check each of the code signatures.\n                for regexp, function in self.signatures:\n                    p = re.compile(regexp, (re.VERBOSE | re.DOTALL))\n                    m = p.match(block)\n                    if m:\n                        # Put everything in a dictionary.\n                        captures = m.groupdict()\n\n                        # If we are extending a block, we require a dot to\n                        # break it, so we can start lines with '#' inside\n                        # an extended <pre> without matching an ordered list.\n                        if extending and not captures.get('dot', None):\n                            output[-1][1]['text'] += block\n                            break \n                        elif captures.has_key('dot'):\n                            del captures['dot']\n                            \n                        # If a signature matches, we are not extending a block.\n                        extending = 0\n\n                        # Check if we should extend this block.\n                        if captures.has_key('extend'):\n                            extending = captures['extend']\n                            del captures['extend']\n                            \n                        # Apply head_offset.\n                        if captures.has_key('header'):\n                            captures['header'] = int(captures['header']) + self.head_offset\n\n                        # Apply clear.\n                        if clear:\n                            captures['clear'] = clear\n                            clear = None\n\n                        # Save the block to be processed later.\n                        output.append([function, captures])\n\n                        break\n\n                else:\n                    if extending:\n                        # Append the text to the last block.\n                        output[-1][1]['text'] += block\n                    elif block.strip():\n                        output.append([self.paragraph, {'text': block}])\n    \n        return output","function_tokens":["def","split_text","(","self",")",":","# Clear signature.","clear_sig","=","r'''^clear(?P<alignment>[<>])?\\.$'''","clear","=","None","extending","=","0","# We capture the \\n's because they are important inside \"pre..\".","blocks","=","re",".","split","(","r'''((\\n\\s*){2,})'''",",","self",".","text",")","output","=","[","]","for","block","in","blocks",":","# Check for the clear signature.","m","=","re",".","match","(","clear_sig",",","block",")","if","m",":","clear","=","m",".","group","(","'alignment'",")","if","clear",":","clear","=","{","'<'",":","'clear:left;'",",","'>'",":","'clear:right;'","}","[","clear","]","else",":","clear","=","'clear:both;'","else",":","# Check each of the code signatures.","for","regexp",",","function","in","self",".","signatures",":","p","=","re",".","compile","(","regexp",",","(","re",".","VERBOSE","|","re",".","DOTALL",")",")","m","=","p",".","match","(","block",")","if","m",":","# Put everything in a dictionary.","captures","=","m",".","groupdict","(",")","# If we are extending a block, we require a dot to","# break it, so we can start lines with '#' inside","# an extended <pre> without matching an ordered list.","if","extending","and","not","captures",".","get","(","'dot'",",","None",")",":","output","[","-","1","]","[","1","]","[","'text'","]","+=","block","break","elif","captures",".","has_key","(","'dot'",")",":","del","captures","[","'dot'","]","# If a signature matches, we are not extending a block.","extending","=","0","# Check if we should extend this block.","if","captures",".","has_key","(","'extend'",")",":","extending","=","captures","[","'extend'","]","del","captures","[","'extend'","]","# Apply head_offset.","if","captures",".","has_key","(","'header'",")",":","captures","[","'header'","]","=","int","(","captures","[","'header'","]",")","+","self",".","head_offset","# Apply clear.","if","clear",":","captures","[","'clear'","]","=","clear","clear","=","None","# Save the block to be processed later.","output",".","append","(","[","function",",","captures","]",")","break","else",":","if","extending",":","# Append the text to the last block.","output","[","-","1","]","[","1","]","[","'text'","]","+=","block","elif","block",".","strip","(",")",":","output",".","append","(","[","self",".","paragraph",",","{","'text'",":","block","}","]",")","return","output"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L892-L1015"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.parse_params","parameters":"(self, parameters, clear=None, align_type='block')","argument_list":"","return_statement":"return output","docstring":"Parse the parameters from a block signature.\n\n        This function parses the parameters from a block signature,\n        splitting the information about class, id, language and\n        style. The positioning (indentation and alignment) is parsed\n        and stored in the style.\n\n        A paragraph like:\n\n            p>(class#id){color:red}[en]. Paragraph.\n\n        or:\n            \n            p{color:red}[en](class#id)>. Paragraph.\n\n        will have its parameters parsed to:\n\n            output = {'lang' : 'en',\n                      'class': 'class',\n                      'id'   : 'id',\n                      'style': 'color:red;text-align:right;'}\n\n        Note that order is not important.","docstring_summary":"Parse the parameters from a block signature.","docstring_tokens":["Parse","the","parameters","from","a","block","signature","."],"function":"def parse_params(self, parameters, clear=None, align_type='block'):\n        \"\"\"Parse the parameters from a block signature.\n\n        This function parses the parameters from a block signature,\n        splitting the information about class, id, language and\n        style. The positioning (indentation and alignment) is parsed\n        and stored in the style.\n\n        A paragraph like:\n\n            p>(class#id){color:red}[en]. Paragraph.\n\n        or:\n            \n            p{color:red}[en](class#id)>. Paragraph.\n\n        will have its parameters parsed to:\n\n            output = {'lang' : 'en',\n                      'class': 'class',\n                      'id'   : 'id',\n                      'style': 'color:red;text-align:right;'}\n\n        Note that order is not important.\n        \"\"\"\n        if not parameters:\n            if clear:\n                return {'style': clear}\n            else:\n                return {}\n\n        output = {}\n        \n        # Match class from (class) or (class#id).\n        m = re.search(r'''\\((?P<class>[\\w]+(\\s[\\w]+)*)(\\#[\\w]+)?\\)''', parameters)\n        if m: output['class'] = m.group('class')\n\n        # Match id from (#id) or (class#id).\n        m = re.search(r'''\\([\\w]*(\\s[\\w]+)*\\#(?P<id>[\\w]+)\\)''', parameters)\n        if m: output['id'] = m.group('id')\n\n        # Match [language].\n        m = re.search(r'''\\[(?P<lang>[\\w-]+)\\]''', parameters)\n        if m: output['lang'] = m.group('lang')\n\n        # Match {style}.\n        m = re.search(r'''{(?P<style>[^\\}]+)}''', parameters)\n        if m:\n            output['style'] = m.group('style').replace('\\n', '')\n\n            # If necessary, apppend a semi-comma to the style.\n            if not output['style'].endswith(';'):\n                output['style'] += ';'\n\n        # Clear the block?\n        if clear:\n            output['style'] = output.get('style', '') + clear\n\n        # Remove classes, ids, langs and styles. This makes the \n        # regular expression for the positioning much easier.\n        parameters = preg_replace(r'''\\([\\#\\w\\s]+\\)''', '', parameters)\n        parameters = preg_replace(r'''\\[[\\w-]+\\]''', '', parameters)\n        parameters = preg_replace(r'''{[\\w:;#%-]+}''', '', parameters)\n\n        style = []\n        \n        # Count the left indentation.\n        l_indent = parameters.count('(')\n        if l_indent: style.append('padding-left:%dem;' % l_indent)\n\n        # Count the right indentation.\n        r_indent = parameters.count(')')\n        if r_indent: style.append('padding-right:%dem;' % r_indent)\n\n        # Add alignment.\n        if align_type == 'image':\n            align = [('<', 'float:left;', ' left'),\n                     ('>', 'float:right;', ' right')]\n\n            valign = [('^', 'vertical-align:text-top;', ' top'),\n                      ('-', 'vertical-align:middle;', ' middle'),\n                      ('~', 'vertical-align:text-bottom;', ' bottom')]\n\n            # Images can have both a vertical and a horizontal alignment.\n            for alignments in [align, valign]:\n                for _align, _style, _class in alignments:\n                    if parameters.count(_align):\n                        style.append(_style)\n                        \n                        # Append a class name related to the alignment.\n                        output['class'] = output.get('class', '') + _class\n                        break\n\n        elif align_type == 'table':\n            align = [('<', 'left'),\n                     ('>', 'right'),\n                     ('=', 'center'),\n                     ('<>', 'justify')]\n\n            valign = [('^', 'top'),\n                      ('~', 'bottom')]\n\n            # Horizontal alignment.\n            for _align, _style, in align:\n                if parameters.count(_align):\n                    output['align'] = _style\n            \n            # Vertical alignment.\n            for _align, _style, in valign:\n                if parameters.count(_align):\n                    output['valign'] = _style\n\n            # Colspan and rowspan.\n            m = re.search(r'''\\\\(\\d+)''', parameters)\n            if m:\n                #output['colspan'] = m.groups()\n                output['colspan'] = int(m.groups()[0])\n\n            m = re.search(r'''\/(\\d+)''', parameters)\n            if m:\n                output['rowspan'] = int(m.groups()[0])\n\n        else:\n            if l_indent or r_indent:\n                alignments = [('<>', 'text-align:justify;', ' justify'),\n                              ('=', 'text-align:center;', ' center'),\n                              ('<', 'float:left;', ' left'),\n                              ('>', 'float:right;', ' right')]\n            else:\n                alignments = [('<>', 'text-align:justify;', ' justify'),\n                              ('=', 'text-align:center;', ' center'),\n                              ('<', 'text-align:left;', ' left'),\n                              ('>', 'text-align:right;', ' right')]\n\n            for _align, _style, _class in alignments:\n                if parameters.count(_align):\n                    style.append(_style)\n\n                    # Append a class name related to the alignment.\n                    output['class'] = output.get('class', '') + _class\n                    break\n\n        # Join all the styles.\n        output['style'] = output.get('style', '') + ''.join(style)\n\n        # Remove excess whitespace.\n        if output.has_key('class'):\n            output['class'] = output['class'].strip()\n\n        return output","function_tokens":["def","parse_params","(","self",",","parameters",",","clear","=","None",",","align_type","=","'block'",")",":","if","not","parameters",":","if","clear",":","return","{","'style'",":","clear","}","else",":","return","{","}","output","=","{","}","# Match class from (class) or (class#id).","m","=","re",".","search","(","r'''\\((?P<class>[\\w]+(\\s[\\w]+)*)(\\#[\\w]+)?\\)'''",",","parameters",")","if","m",":","output","[","'class'","]","=","m",".","group","(","'class'",")","# Match id from (#id) or (class#id).","m","=","re",".","search","(","r'''\\([\\w]*(\\s[\\w]+)*\\#(?P<id>[\\w]+)\\)'''",",","parameters",")","if","m",":","output","[","'id'","]","=","m",".","group","(","'id'",")","# Match [language].","m","=","re",".","search","(","r'''\\[(?P<lang>[\\w-]+)\\]'''",",","parameters",")","if","m",":","output","[","'lang'","]","=","m",".","group","(","'lang'",")","# Match {style}.","m","=","re",".","search","(","r'''{(?P<style>[^\\}]+)}'''",",","parameters",")","if","m",":","output","[","'style'","]","=","m",".","group","(","'style'",")",".","replace","(","'\\n'",",","''",")","# If necessary, apppend a semi-comma to the style.","if","not","output","[","'style'","]",".","endswith","(","';'",")",":","output","[","'style'","]","+=","';'","# Clear the block?","if","clear",":","output","[","'style'","]","=","output",".","get","(","'style'",",","''",")","+","clear","# Remove classes, ids, langs and styles. This makes the ","# regular expression for the positioning much easier.","parameters","=","preg_replace","(","r'''\\([\\#\\w\\s]+\\)'''",",","''",",","parameters",")","parameters","=","preg_replace","(","r'''\\[[\\w-]+\\]'''",",","''",",","parameters",")","parameters","=","preg_replace","(","r'''{[\\w:;#%-]+}'''",",","''",",","parameters",")","style","=","[","]","# Count the left indentation.","l_indent","=","parameters",".","count","(","'('",")","if","l_indent",":","style",".","append","(","'padding-left:%dem;'","%","l_indent",")","# Count the right indentation.","r_indent","=","parameters",".","count","(","')'",")","if","r_indent",":","style",".","append","(","'padding-right:%dem;'","%","r_indent",")","# Add alignment.","if","align_type","==","'image'",":","align","=","[","(","'<'",",","'float:left;'",",","' left'",")",",","(","'>'",",","'float:right;'",",","' right'",")","]","valign","=","[","(","'^'",",","'vertical-align:text-top;'",",","' top'",")",",","(","'-'",",","'vertical-align:middle;'",",","' middle'",")",",","(","'~'",",","'vertical-align:text-bottom;'",",","' bottom'",")","]","# Images can have both a vertical and a horizontal alignment.","for","alignments","in","[","align",",","valign","]",":","for","_align",",","_style",",","_class","in","alignments",":","if","parameters",".","count","(","_align",")",":","style",".","append","(","_style",")","# Append a class name related to the alignment.","output","[","'class'","]","=","output",".","get","(","'class'",",","''",")","+","_class","break","elif","align_type","==","'table'",":","align","=","[","(","'<'",",","'left'",")",",","(","'>'",",","'right'",")",",","(","'='",",","'center'",")",",","(","'<>'",",","'justify'",")","]","valign","=","[","(","'^'",",","'top'",")",",","(","'~'",",","'bottom'",")","]","# Horizontal alignment.","for","_align",",","_style",",","in","align",":","if","parameters",".","count","(","_align",")",":","output","[","'align'","]","=","_style","# Vertical alignment.","for","_align",",","_style",",","in","valign",":","if","parameters",".","count","(","_align",")",":","output","[","'valign'","]","=","_style","# Colspan and rowspan.","m","=","re",".","search","(","r'''\\\\(\\d+)'''",",","parameters",")","if","m",":","#output['colspan'] = m.groups()","output","[","'colspan'","]","=","int","(","m",".","groups","(",")","[","0","]",")","m","=","re",".","search","(","r'''\/(\\d+)'''",",","parameters",")","if","m",":","output","[","'rowspan'","]","=","int","(","m",".","groups","(",")","[","0","]",")","else",":","if","l_indent","or","r_indent",":","alignments","=","[","(","'<>'",",","'text-align:justify;'",",","' justify'",")",",","(","'='",",","'text-align:center;'",",","' center'",")",",","(","'<'",",","'float:left;'",",","' left'",")",",","(","'>'",",","'float:right;'",",","' right'",")","]","else",":","alignments","=","[","(","'<>'",",","'text-align:justify;'",",","' justify'",")",",","(","'='",",","'text-align:center;'",",","' center'",")",",","(","'<'",",","'text-align:left;'",",","' left'",")",",","(","'>'",",","'text-align:right;'",",","' right'",")","]","for","_align",",","_style",",","_class","in","alignments",":","if","parameters",".","count","(","_align",")",":","style",".","append","(","_style",")","# Append a class name related to the alignment.","output","[","'class'","]","=","output",".","get","(","'class'",",","''",")","+","_class","break","# Join all the styles.","output","[","'style'","]","=","output",".","get","(","'style'",",","''",")","+","''",".","join","(","style",")","# Remove excess whitespace.","if","output",".","has_key","(","'class'",")",":","output","[","'class'","]","=","output","[","'class'","]",".","strip","(",")","return","output"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1018-L1167"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.build_open_tag","parameters":"(self, tag, attributes={}, single=0)","argument_list":"","return_statement":"return ''.join(open_tag)","docstring":"Build the open tag with specified attributes.\n\n        This function is used by all block builders to \n        generate the opening tags with the attributes of\n        the block.","docstring_summary":"Build the open tag with specified attributes.","docstring_tokens":["Build","the","open","tag","with","specified","attributes","."],"function":"def build_open_tag(self, tag, attributes={}, single=0):\n        \"\"\"Build the open tag with specified attributes.\n\n        This function is used by all block builders to \n        generate the opening tags with the attributes of\n        the block.\n        \"\"\"\n        # Open tag.\n        open_tag = ['<%s' % tag]\n        for k,v in attributes.items():\n            # The ALT attribute can be empty.\n            if k == 'alt' or v: open_tag.append(' %s=\"%s\"' % (k, v))\n\n        if single:\n            open_tag.append(' \/')\n\n        # Close tag.\n        open_tag.append('>')\n\n        return ''.join(open_tag)","function_tokens":["def","build_open_tag","(","self",",","tag",",","attributes","=","{","}",",","single","=","0",")",":","# Open tag.","open_tag","=","[","'<%s'","%","tag","]","for","k",",","v","in","attributes",".","items","(",")",":","# The ALT attribute can be empty.","if","k","==","'alt'","or","v",":","open_tag",".","append","(","' %s=\"%s\"'","%","(","k",",","v",")",")","if","single",":","open_tag",".","append","(","' \/'",")","# Close tag.","open_tag",".","append","(","'>'",")","return","''",".","join","(","open_tag",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1170-L1189"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.paragraph","parameters":"(self, text, parameters=None, attributes=None, clear=None)","argument_list":"","return_statement":"return '\\n\\n'.join(output)","docstring":"Process a paragraph.\n\n        This function processes the paragraphs, enclosing the text in a \n        <p> tag and breaking lines with <br \/>. Paragraphs are formatted\n        with all the inline rules.\n\n        ---\n        h1. Paragraph\n        \n        This is how you write a paragraph:\n\n        pre. p. This is a paragraph, although a short one.\n        \n        Since the paragraph is the default block, you can safely omit its\n        signature ([@p@]). Simply write:\n\n        pre. This is a paragraph, although a short one.\n\n        Text in a paragraph block is wrapped in @<p><\/p>@ tags, and\n        newlines receive a <br \/> tag. In both cases Textile will process\n        the text to:\n\n        pre. <p>This is a paragraph, although a short one.<\/p>\n\n        Text in a paragraph block is processed with all the inline rules.","docstring_summary":"Process a paragraph.","docstring_tokens":["Process","a","paragraph","."],"function":"def paragraph(self, text, parameters=None, attributes=None, clear=None):\n        \"\"\"Process a paragraph.\n\n        This function processes the paragraphs, enclosing the text in a \n        <p> tag and breaking lines with <br \/>. Paragraphs are formatted\n        with all the inline rules.\n\n        ---\n        h1. Paragraph\n        \n        This is how you write a paragraph:\n\n        pre. p. This is a paragraph, although a short one.\n        \n        Since the paragraph is the default block, you can safely omit its\n        signature ([@p@]). Simply write:\n\n        pre. This is a paragraph, although a short one.\n\n        Text in a paragraph block is wrapped in @<p><\/p>@ tags, and\n        newlines receive a <br \/> tag. In both cases Textile will process\n        the text to:\n\n        pre. <p>This is a paragraph, although a short one.<\/p>\n\n        Text in a paragraph block is processed with all the inline rules.\n        \"\"\"\n        # Split the lines.\n        lines = re.split('\\n{2,}', text)\n        \n        # Get the attributes.\n        attributes = attributes or self.parse_params(parameters, clear)\n\n        output = []\n        for line in lines:\n            if line:\n                # Clean the line.\n                line = line.strip()\n                 \n                # Build the tag.\n                open_tag = self.build_open_tag('p', attributes)\n                close_tag = '<\/p>'\n\n                # Pop the id because it must be unique.\n                if attributes.has_key('id'): del attributes['id']\n\n                # Break lines. \n                line = preg_replace(r'(<br \/>|\\n)+', '<br \/>\\n', line)\n\n                # Remove <br \/> from inside broken HTML tags.\n                line = preg_replace(r'(<[^>]*)<br \/>\\n(.*?>)', r'\\1 \\2', line)\n\n                # Inline formatting.\n                line = self.inline(line)\n\n                output.append(open_tag + line + close_tag)\n\n        return '\\n\\n'.join(output)","function_tokens":["def","paragraph","(","self",",","text",",","parameters","=","None",",","attributes","=","None",",","clear","=","None",")",":","# Split the lines.","lines","=","re",".","split","(","'\\n{2,}'",",","text",")","# Get the attributes.","attributes","=","attributes","or","self",".","parse_params","(","parameters",",","clear",")","output","=","[","]","for","line","in","lines",":","if","line",":","# Clean the line.","line","=","line",".","strip","(",")","# Build the tag.","open_tag","=","self",".","build_open_tag","(","'p'",",","attributes",")","close_tag","=","'<\/p>'","# Pop the id because it must be unique.","if","attributes",".","has_key","(","'id'",")",":","del","attributes","[","'id'","]","# Break lines. ","line","=","preg_replace","(","r'(<br \/>|\\n)+'",",","'<br \/>\\n'",",","line",")","# Remove <br \/> from inside broken HTML tags.","line","=","preg_replace","(","r'(<[^>]*)<br \/>\\n(.*?>)'",",","r'\\1 \\2'",",","line",")","# Inline formatting.","line","=","self",".","inline","(","line",")","output",".","append","(","open_tag","+","line","+","close_tag",")","return","'\\n\\n'",".","join","(","output",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1192-L1249"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.pre","parameters":"(self, text, parameters=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Process pre-formatted text.\n\n        This function processes pre-formatted text into a <pre> tag.\n        No HTML is added for the lines, but @<@ and @>@ are translated into\n        HTML entities.\n\n        ---\n        h1. Pre-formatted text\n\n        Pre-formatted text can be specified using the @pre@ signature.\n        Inside a \"pre\" block, whitespace is preserved and @<@ and @>@ are\n        translated into HTML(HyperText Markup Language) entities\n        automatically.\n\n        Text in a \"pre\" block is _not processed_ with any inline rule.\n\n        Here's a simple example:\n\n        pre. pre. This text is pre-formatted.\n        Nothing interesting happens inside here...\n        \n        Will become:\n\n        pre. <pre>\n        This text is pre-formatted.\n        Nothing interesting happens inside here...\n        <\/pre>","docstring_summary":"Process pre-formatted text.","docstring_tokens":["Process","pre","-","formatted","text","."],"function":"def pre(self, text, parameters=None, clear=None):\n        \"\"\"Process pre-formatted text.\n\n        This function processes pre-formatted text into a <pre> tag.\n        No HTML is added for the lines, but @<@ and @>@ are translated into\n        HTML entities.\n\n        ---\n        h1. Pre-formatted text\n\n        Pre-formatted text can be specified using the @pre@ signature.\n        Inside a \"pre\" block, whitespace is preserved and @<@ and @>@ are\n        translated into HTML(HyperText Markup Language) entities\n        automatically.\n\n        Text in a \"pre\" block is _not processed_ with any inline rule.\n\n        Here's a simple example:\n\n        pre. pre. This text is pre-formatted.\n        Nothing interesting happens inside here...\n        \n        Will become:\n\n        pre. <pre>\n        This text is pre-formatted.\n        Nothing interesting happens inside here...\n        <\/pre>\n        \"\"\"\n\n        # Remove trailing whitespace.\n        text = text.rstrip()\n\n        # Get the attributes.\n        attributes = self.parse_params(parameters, clear)\n\n        # Build the tag.\n        #open_tag = self.build_open_tag('pre', attributes) + '\\n'\n        open_tag = self.build_open_tag('pre', attributes)\n        close_tag = '\\n<\/pre>'\n\n        # Replace < and >.\n        text = text.replace('<', '&lt;')\n        text = text.replace('>', '&gt;')\n\n        return open_tag + text + close_tag","function_tokens":["def","pre","(","self",",","text",",","parameters","=","None",",","clear","=","None",")",":","# Remove trailing whitespace.","text","=","text",".","rstrip","(",")","# Get the attributes.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","# Build the tag.","#open_tag = self.build_open_tag('pre', attributes) + '\\n'","open_tag","=","self",".","build_open_tag","(","'pre'",",","attributes",")","close_tag","=","'\\n<\/pre>'","# Replace < and >.","text","=","text",".","replace","(","'<'",",","'&lt;'",")","text","=","text",".","replace","(","'>'",",","'&gt;'",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1252-L1297"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.bc","parameters":"(self, text, parameters=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Process block code.\n\n        This function processes block code into a <code> tag inside a\n        <pre>. No HTML is added for the lines, but @<@ and @>@ are translated\n        into HTML entities.\n\n        ---\n        h1. Block code\n\n        A block code, specified by the @bc@ signature, is a block of\n        pre-formatted text which also receives a @<code><\/code>@ tag. As\n        with \"pre\", whitespace is preserved and @<@ and @>@ are translated\n        into HTML(HyperText Markup Language) entities automatically.\n\n        Text in a \"bc\" code is _not processed_ with the inline rules.\n        \n        If you have \"Twisted\":http:\/\/www.twistedmatrix.com\/ installed,\n        Textile can automatically colorize your Python code if you\n        specify its language as \"Python\":\n        \n        pre. bc[python]. from twisted.python import htmlizer\n\n        This will become:\n\n        pre. <pre>\n        <code lang=\"python\">\n        <span class=\"py-src-keyword\">from<\/span> <span class=\"py-src-variable\">twisted<\/span><span class=\"py-src-op\">.<\/span><span class=\"py-src-variable\">python<\/span> <span class=\"py-src-keyword\">import<\/span> <span class=\"py-src-variable\">htmlizer<\/span>\n        <\/code>\n        <\/pre>\n\n        The colors can be specified in your CSS(Cascading Style Sheets)\n        file. If you don't want to install Twisted, you can download just\n        the @htmlizer@ module \"independently\":http:\/\/dealmeida.net\/code\/htmlizer.py.txt.","docstring_summary":"Process block code.","docstring_tokens":["Process","block","code","."],"function":"def bc(self, text, parameters=None, clear=None):\n        \"\"\"Process block code.\n\n        This function processes block code into a <code> tag inside a\n        <pre>. No HTML is added for the lines, but @<@ and @>@ are translated\n        into HTML entities.\n\n        ---\n        h1. Block code\n\n        A block code, specified by the @bc@ signature, is a block of\n        pre-formatted text which also receives a @<code><\/code>@ tag. As\n        with \"pre\", whitespace is preserved and @<@ and @>@ are translated\n        into HTML(HyperText Markup Language) entities automatically.\n\n        Text in a \"bc\" code is _not processed_ with the inline rules.\n        \n        If you have \"Twisted\":http:\/\/www.twistedmatrix.com\/ installed,\n        Textile can automatically colorize your Python code if you\n        specify its language as \"Python\":\n        \n        pre. bc[python]. from twisted.python import htmlizer\n\n        This will become:\n\n        pre. <pre>\n        <code lang=\"python\">\n        <span class=\"py-src-keyword\">from<\/span> <span class=\"py-src-variable\">twisted<\/span><span class=\"py-src-op\">.<\/span><span class=\"py-src-variable\">python<\/span> <span class=\"py-src-keyword\">import<\/span> <span class=\"py-src-variable\">htmlizer<\/span>\n        <\/code>\n        <\/pre>\n\n        The colors can be specified in your CSS(Cascading Style Sheets)\n        file. If you don't want to install Twisted, you can download just\n        the @htmlizer@ module \"independently\":http:\/\/dealmeida.net\/code\/htmlizer.py.txt.\n        \"\"\"\n\n        # Get the attributes.\n        attributes = self.parse_params(parameters, clear)\n\n        # XHTML <code> can't have the attribute lang.\n        if attributes.has_key('lang'):\n            lang = attributes['lang']\n            del attributes['lang']\n        else:\n            lang = None\n\n        # Build the tag.\n        open_tag = '<pre>\\n' + self.build_open_tag('code', attributes) + '\\n'\n        close_tag = '\\n<\/code>\\n<\/pre>'\n\n        # Colorize Python code?\n        if htmlizer and lang == 'python':\n            text = _color(text)\n        else:\n            # Replace < and >.\n            text = text.replace('<', '&lt;')\n            text = text.replace('>', '&gt;')\n\n        return open_tag + text + close_tag","function_tokens":["def","bc","(","self",",","text",",","parameters","=","None",",","clear","=","None",")",":","# Get the attributes.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","# XHTML <code> can't have the attribute lang.","if","attributes",".","has_key","(","'lang'",")",":","lang","=","attributes","[","'lang'","]","del","attributes","[","'lang'","]","else",":","lang","=","None","# Build the tag.","open_tag","=","'<pre>\\n'","+","self",".","build_open_tag","(","'code'",",","attributes",")","+","'\\n'","close_tag","=","'\\n<\/code>\\n<\/pre>'","# Colorize Python code?","if","htmlizer","and","lang","==","'python'",":","text","=","_color","(","text",")","else",":","# Replace < and >.","text","=","text",".","replace","(","'<'",",","'&lt;'",")","text","=","text",".","replace","(","'>'",",","'&gt;'",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1300-L1358"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.dl","parameters":"(self, text, parameters=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Process definition list.\n\n        This function process definition lists. The text inside\n        the <dt> and <dd> tags is processed for inline formatting.\n\n        ---\n        h1. Definition list\n\n        A definition list starts with the signature @dl@, and has\n        its items separated by a @:@. Here's a simple example:\n\n        pre. dl. name:Sir Lancelot of Camelot.\n        quest:To seek the Holy Grail.\n        color:Blue.\n\n        Becomes:\n\n        pre. <dl>\n        <dt>name<\/dt>\n        <dd>Sir Lancelot of Camelot.<\/dd>\n        <dt>quest<\/dt>\n        <dd>To seek the Holy Grail.<\/dd>\n        <dt>color<\/dt>\n        <dd>Blue.<\/dd>\n        <\/dl>","docstring_summary":"Process definition list.","docstring_tokens":["Process","definition","list","."],"function":"def dl(self, text, parameters=None, clear=None):\n        \"\"\"Process definition list.\n\n        This function process definition lists. The text inside\n        the <dt> and <dd> tags is processed for inline formatting.\n\n        ---\n        h1. Definition list\n\n        A definition list starts with the signature @dl@, and has\n        its items separated by a @:@. Here's a simple example:\n\n        pre. dl. name:Sir Lancelot of Camelot.\n        quest:To seek the Holy Grail.\n        color:Blue.\n\n        Becomes:\n\n        pre. <dl>\n        <dt>name<\/dt>\n        <dd>Sir Lancelot of Camelot.<\/dd>\n        <dt>quest<\/dt>\n        <dd>To seek the Holy Grail.<\/dd>\n        <dt>color<\/dt>\n        <dd>Blue.<\/dd>\n        <\/dl>\n        \"\"\"\n        # Get the attributes.\n        attributes = self.parse_params(parameters, clear)\n\n        # Build the tag.\n        open_tag = self.build_open_tag('dl', attributes) + '\\n'\n        close_tag = '\\n<\/dl>'\n\n        lines = text.split('\\n')\n        output = []\n        for line in lines:\n            if line.count(':'):\n                [dt, dd] = line.split(':', 1)\n            else:\n                dt,dd = line, ''\n\n            if dt: output.append('<dt>%s<\/dt>\\n<dd>%s<\/dd>' % (dt, dd))\n\n        text = '\\n'.join(output)\n\n        text = self.inline(text)\n\n        return open_tag + text + close_tag","function_tokens":["def","dl","(","self",",","text",",","parameters","=","None",",","clear","=","None",")",":","# Get the attributes.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","# Build the tag.","open_tag","=","self",".","build_open_tag","(","'dl'",",","attributes",")","+","'\\n'","close_tag","=","'\\n<\/dl>'","lines","=","text",".","split","(","'\\n'",")","output","=","[","]","for","line","in","lines",":","if","line",".","count","(","':'",")",":","[","dt",",","dd","]","=","line",".","split","(","':'",",","1",")","else",":","dt",",","dd","=","line",",","''","if","dt",":","output",".","append","(","'<dt>%s<\/dt>\\n<dd>%s<\/dd>'","%","(","dt",",","dd",")",")","text","=","'\\n'",".","join","(","output",")","text","=","self",".","inline","(","text",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1361-L1409"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.blockquote","parameters":"(self, text, parameters=None, cite=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Process block quote.\n\n        The block quote is inserted into a <blockquote> tag, and\n        processed as a paragraph. An optional cite attribute can\n        be appended on the last line after two dashes (--), or\n        after the period following ':' for compatibility with the\n        Perl version.\n\n        ---\n        h1. Blockquote\n\n        A blockquote is denoted by the signature @bq@. The text in this\n        block will be enclosed in @<blockquote><\/blockquote>@ and @<p><\/p>@,\n        receiving the same formatting as a paragraph. For example:\n\n        pre. bq. This is a blockquote.\n\n        Becomes:\n\n        pre. <blockquote>\n        <p>This is a blockquote.<\/p>\n        <\/blockquote>\n\n        You can optionally specify the @cite@ attribute of the blockquote,\n        using the following syntax:\n\n        pre. bq.:http:\/\/example.com Some text.\n\n        pre. bq.:\"John Doe\" Some other text.\n\n        Becomes:\n\n        pre. <blockquote cite=\"http:\/\/example.com\">\n        <p>Some text.<\/p>\n        <\/blockquote>\n\n        pre. <blockquote cite=\"John Doe\">\n        <p>Some other text.<\/p>\n        <\/blockquote>\n\n        You can also specify the @cite@ using a pair of dashes on the\n        last line of the blockquote:\n\n        pre. bq. Some text.\n        -- http:\/\/example.com","docstring_summary":"Process block quote.","docstring_tokens":["Process","block","quote","."],"function":"def blockquote(self, text, parameters=None, cite=None, clear=None):\n        \"\"\"Process block quote.\n\n        The block quote is inserted into a <blockquote> tag, and\n        processed as a paragraph. An optional cite attribute can\n        be appended on the last line after two dashes (--), or\n        after the period following ':' for compatibility with the\n        Perl version.\n\n        ---\n        h1. Blockquote\n\n        A blockquote is denoted by the signature @bq@. The text in this\n        block will be enclosed in @<blockquote><\/blockquote>@ and @<p><\/p>@,\n        receiving the same formatting as a paragraph. For example:\n\n        pre. bq. This is a blockquote.\n\n        Becomes:\n\n        pre. <blockquote>\n        <p>This is a blockquote.<\/p>\n        <\/blockquote>\n\n        You can optionally specify the @cite@ attribute of the blockquote,\n        using the following syntax:\n\n        pre. bq.:http:\/\/example.com Some text.\n\n        pre. bq.:\"John Doe\" Some other text.\n\n        Becomes:\n\n        pre. <blockquote cite=\"http:\/\/example.com\">\n        <p>Some text.<\/p>\n        <\/blockquote>\n\n        pre. <blockquote cite=\"John Doe\">\n        <p>Some other text.<\/p>\n        <\/blockquote>\n\n        You can also specify the @cite@ using a pair of dashes on the\n        last line of the blockquote:\n\n        pre. bq. Some text.\n        -- http:\/\/example.com\n        \"\"\"\n\n        # Get the attributes.\n        attributes = self.parse_params(parameters, clear)\n\n        if cite:\n            # Remove the quotes?\n            cite = cite.strip('\"')\n            attributes['cite'] = cite\n        else:\n            # The citation should be on the last line.\n            text = text.split('\\n')\n            if text[-1].startswith('-- '):\n                attributes['cite'] = text.pop()[3:]    \n        \n            text = '\\n'.join(text)\n\n        # Build the tag.\n        open_tag = self.build_open_tag('blockquote', attributes) + '\\n'\n        close_tag = '\\n<\/blockquote>'\n\n        # Process the paragraph, passing the attributes.\n        # Does it make sense to pass the id, class, etc. to\n        # the paragraph instead of applying it to the\n        # blockquote tag?\n        text = self.paragraph(text)\n        \n        return open_tag + text + close_tag","function_tokens":["def","blockquote","(","self",",","text",",","parameters","=","None",",","cite","=","None",",","clear","=","None",")",":","# Get the attributes.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","if","cite",":","# Remove the quotes?","cite","=","cite",".","strip","(","'\"'",")","attributes","[","'cite'","]","=","cite","else",":","# The citation should be on the last line.","text","=","text",".","split","(","'\\n'",")","if","text","[","-","1","]",".","startswith","(","'-- '",")",":","attributes","[","'cite'","]","=","text",".","pop","(",")","[","3",":","]","text","=","'\\n'",".","join","(","text",")","# Build the tag.","open_tag","=","self",".","build_open_tag","(","'blockquote'",",","attributes",")","+","'\\n'","close_tag","=","'\\n<\/blockquote>'","# Process the paragraph, passing the attributes.","# Does it make sense to pass the id, class, etc. to","# the paragraph instead of applying it to the","# blockquote tag?","text","=","self",".","paragraph","(","text",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1412-L1485"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.header","parameters":"(self, text, parameters=None, header=1, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Process a header.\n\n        The header number is captured by the regular \n        expression and lives in header. If head_offset is\n        set, it is adjusted accordingly.\n\n        ---\n        h1. Header\n\n        A header is produced by the signature @hn@, where @n@ goes\n        from 1 to 6. You can adjust the relative output of the headers\n        passing a @head_offset@ attribute when calling @textile()@.\n\n        To make a header:\n\n        pre. h1. This is a header.\n\n        Becomes:\n\n        pre. <h1>This is a header.<\/h1>","docstring_summary":"Process a header.","docstring_tokens":["Process","a","header","."],"function":"def header(self, text, parameters=None, header=1, clear=None):\n        \"\"\"Process a header.\n\n        The header number is captured by the regular \n        expression and lives in header. If head_offset is\n        set, it is adjusted accordingly.\n\n        ---\n        h1. Header\n\n        A header is produced by the signature @hn@, where @n@ goes\n        from 1 to 6. You can adjust the relative output of the headers\n        passing a @head_offset@ attribute when calling @textile()@.\n\n        To make a header:\n\n        pre. h1. This is a header.\n\n        Becomes:\n\n        pre. <h1>This is a header.<\/h1>\n        \"\"\"\n        # Get the attributes.\n        attributes = self.parse_params(parameters, clear)\n\n        # Get the header number and limit it between 1 and 6.\n        n = header\n        n = min(n,6)\n        n = max(n,1)\n\n        # Build the tag.\n        open_tag = self.build_open_tag('h%d' % n, attributes)\n        close_tag = '<\/h%d>' % n\n\n        text = self.inline(text)\n\n        return open_tag + text + close_tag","function_tokens":["def","header","(","self",",","text",",","parameters","=","None",",","header","=","1",",","clear","=","None",")",":","# Get the attributes.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","# Get the header number and limit it between 1 and 6.","n","=","header","n","=","min","(","n",",","6",")","n","=","max","(","n",",","1",")","# Build the tag.","open_tag","=","self",".","build_open_tag","(","'h%d'","%","n",",","attributes",")","close_tag","=","'<\/h%d>'","%","n","text","=","self",".","inline","(","text",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1488-L1524"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.footnote","parameters":"(self, text, parameters=None, footnote=1, clear=None)","argument_list":"","return_statement":"return self.paragraph(text=text, attributes=attributes)","docstring":"Process a footnote.\n\n        A footnote is formatted as a paragraph of class\n        'footnote' and id 'fn%d', starting with the footnote\n        number in a <sup> tag. Here we just build the\n        attributes and pass them directly to self.paragraph().\n\n        ---\n        h1. Footnote\n\n        A footnote is produced by the signature @fn@ followed by\n        a number. Footnotes are paragraphs of a special CSS(Cascading Style Sheets)\n        class. An example:\n\n        pre. fn1. This is footnote number one.\n\n        Will produce this:\n\n        pre. <p class=\"footnote\" id=\"fn1\"><sup>1<\/sup> This is footnote number one.<\/p>\n\n        This footnote can be referenced anywhere on the text by the\n        following way:\n\n        pre. This is a reference[1] to footnote number one.\n\n        Which becomes:\n\n        pre. <p>This is a reference<sup class=\"footnote\"><a href=\"#fn1\" title=\"This is footnote number one.\">1<\/a><\/sup> to footnote number 1.<\/p>\n\n        Note that the text from the footnote appears in the @title@ of the\n        link pointing to it.","docstring_summary":"Process a footnote.","docstring_tokens":["Process","a","footnote","."],"function":"def footnote(self, text, parameters=None, footnote=1, clear=None):\n        \"\"\"Process a footnote.\n\n        A footnote is formatted as a paragraph of class\n        'footnote' and id 'fn%d', starting with the footnote\n        number in a <sup> tag. Here we just build the\n        attributes and pass them directly to self.paragraph().\n\n        ---\n        h1. Footnote\n\n        A footnote is produced by the signature @fn@ followed by\n        a number. Footnotes are paragraphs of a special CSS(Cascading Style Sheets)\n        class. An example:\n\n        pre. fn1. This is footnote number one.\n\n        Will produce this:\n\n        pre. <p class=\"footnote\" id=\"fn1\"><sup>1<\/sup> This is footnote number one.<\/p>\n\n        This footnote can be referenced anywhere on the text by the\n        following way:\n\n        pre. This is a reference[1] to footnote number one.\n\n        Which becomes:\n\n        pre. <p>This is a reference<sup class=\"footnote\"><a href=\"#fn1\" title=\"This is footnote number one.\">1<\/a><\/sup> to footnote number 1.<\/p>\n\n        Note that the text from the footnote appears in the @title@ of the\n        link pointing to it.\n        \"\"\"\n        # Get the number.\n        n = int(footnote)\n\n        # Build the attributes to the paragraph.\n        attributes = self.parse_params(parameters, clear)\n        attributes['class'] = 'footnote'\n        attributes['id']    = 'fn%d' % n\n\n        # Build the paragraph text.\n        text = ('<sup>%d<\/sup> ' % n) + text\n\n        # And return the paragraph.\n        return self.paragraph(text=text, attributes=attributes)","function_tokens":["def","footnote","(","self",",","text",",","parameters","=","None",",","footnote","=","1",",","clear","=","None",")",":","# Get the number.","n","=","int","(","footnote",")","# Build the attributes to the paragraph.","attributes","=","self",".","parse_params","(","parameters",",","clear",")","attributes","[","'class'","]","=","'footnote'","attributes","[","'id'","]","=","'fn%d'","%","n","# Build the paragraph text.","text","=","(","'<sup>%d<\/sup> '","%","n",")","+","text","# And return the paragraph.","return","self",".","paragraph","(","text","=","text",",","attributes","=","attributes",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1527-L1572"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.build_li","parameters":"(self, items, liattributes)","argument_list":"","return_statement":"return '\\n'.join(lines)","docstring":"Build the list item.\n\n        This function build the list item of an (un)ordered list. It\n        works by peeking at the next list item, and searching for a\n        multi-list. If a multi-list is found, it is processed and \n        appended inside the list item tags, as it should be.","docstring_summary":"Build the list item.","docstring_tokens":["Build","the","list","item","."],"function":"def build_li(self, items, liattributes):\n        \"\"\"Build the list item.\n\n        This function build the list item of an (un)ordered list. It\n        works by peeking at the next list item, and searching for a\n        multi-list. If a multi-list is found, it is processed and \n        appended inside the list item tags, as it should be.\n        \"\"\"\n        lines = []\n        while len(items):\n            item = items.pop(0)\n\n            # Clean the line.\n            item = item.lstrip()\n            item = item.replace('\\n', '<br \/>\\n')\n\n            # Get list item attributes.\n            p = re.compile(r'''^%(liattr)s\\s''' % self.res, re.VERBOSE)\n            m = p.match(item)\n            if m:\n                c = m.groupdict('')\n                liparameters = c['liparameters']\n                item = p.sub('', item)\n            else:\n                liparameters = ''\n\n            liattributes = liattributes or self.parse_params(liparameters)\n            \n            # Build the item tag.\n            open_tag_li = self.build_open_tag('li', liattributes) \n\n            # Reset the attributes, which should be applied\n            # only to the first <li>.\n            liattributes = {}\n\n            # Build the closing tag.\n            close_tag_li = '<\/li>'\n\n            # Multi-list recursive routine.\n            # Here we check the _next_ items for a multi-list. If we\n            # find one, we extract all items of the multi-list and\n            # process them recursively.\n            if len(items):\n                inlist = []\n\n                # Grab all the items that start with # or *.\n                n_item = items.pop(0)\n\n                # Grab the <ol> parameters.\n                p = re.compile(r'''^%(olattr)s''' % self.res, re.VERBOSE)\n                m = p.match(n_item)\n                if m:\n                    c = m.groupdict('')\n                    olparameters = c['olparameters']\n                    tmp = p.sub('', n_item)\n                else:\n                    olparameters = ''\n\n                # Check for an ordered list inside this one.\n                if tmp.startswith('#'):\n                    n_item = tmp\n                    inlist.append(n_item)\n                    while len(items):\n                        # Peek into the next item.\n                        n_item = items.pop(0)\n                        if n_item.startswith('#'):\n                            inlist.append(n_item)\n                        else:\n                            items.insert(0, n_item)\n                            break\n                        \n                    inlist = self.ol('\\n'.join(inlist), olparameters=olparameters)\n                    item = item + '\\n' + inlist + '\\n'\n\n                # Check for an unordered list inside this one.\n                elif tmp.startswith('*'):\n                    n_item = tmp\n                    inlist.append(n_item)\n                    while len(items):\n                        # Peek into the next item.\n                        n_item = items.pop(0)\n                        if n_item.startswith('*'):\n                            inlist.append(n_item)\n                        else:\n                            items.insert(0, n_item)\n                            break\n\n                    inlist = self.ul('\\n'.join(inlist), olparameters=olparameters)\n                    item = item + '\\n' + inlist + '\\n'\n\n                # Otherwise we just put it back in the list.\n                else:\n                    items.insert(0, n_item)\n\n            item = self.inline(item)\n\n            item = open_tag_li + item + close_tag_li\n            lines.append(item)\n\n        return '\\n'.join(lines)","function_tokens":["def","build_li","(","self",",","items",",","liattributes",")",":","lines","=","[","]","while","len","(","items",")",":","item","=","items",".","pop","(","0",")","# Clean the line.","item","=","item",".","lstrip","(",")","item","=","item",".","replace","(","'\\n'",",","'<br \/>\\n'",")","# Get list item attributes.","p","=","re",".","compile","(","r'''^%(liattr)s\\s'''","%","self",".","res",",","re",".","VERBOSE",")","m","=","p",".","match","(","item",")","if","m",":","c","=","m",".","groupdict","(","''",")","liparameters","=","c","[","'liparameters'","]","item","=","p",".","sub","(","''",",","item",")","else",":","liparameters","=","''","liattributes","=","liattributes","or","self",".","parse_params","(","liparameters",")","# Build the item tag.","open_tag_li","=","self",".","build_open_tag","(","'li'",",","liattributes",")","# Reset the attributes, which should be applied","# only to the first <li>.","liattributes","=","{","}","# Build the closing tag.","close_tag_li","=","'<\/li>'","# Multi-list recursive routine.","# Here we check the _next_ items for a multi-list. If we","# find one, we extract all items of the multi-list and","# process them recursively.","if","len","(","items",")",":","inlist","=","[","]","# Grab all the items that start with # or *.","n_item","=","items",".","pop","(","0",")","# Grab the <ol> parameters.","p","=","re",".","compile","(","r'''^%(olattr)s'''","%","self",".","res",",","re",".","VERBOSE",")","m","=","p",".","match","(","n_item",")","if","m",":","c","=","m",".","groupdict","(","''",")","olparameters","=","c","[","'olparameters'","]","tmp","=","p",".","sub","(","''",",","n_item",")","else",":","olparameters","=","''","# Check for an ordered list inside this one.","if","tmp",".","startswith","(","'#'",")",":","n_item","=","tmp","inlist",".","append","(","n_item",")","while","len","(","items",")",":","# Peek into the next item.","n_item","=","items",".","pop","(","0",")","if","n_item",".","startswith","(","'#'",")",":","inlist",".","append","(","n_item",")","else",":","items",".","insert","(","0",",","n_item",")","break","inlist","=","self",".","ol","(","'\\n'",".","join","(","inlist",")",",","olparameters","=","olparameters",")","item","=","item","+","'\\n'","+","inlist","+","'\\n'","# Check for an unordered list inside this one.","elif","tmp",".","startswith","(","'*'",")",":","n_item","=","tmp","inlist",".","append","(","n_item",")","while","len","(","items",")",":","# Peek into the next item.","n_item","=","items",".","pop","(","0",")","if","n_item",".","startswith","(","'*'",")",":","inlist",".","append","(","n_item",")","else",":","items",".","insert","(","0",",","n_item",")","break","inlist","=","self",".","ul","(","'\\n'",".","join","(","inlist",")",",","olparameters","=","olparameters",")","item","=","item","+","'\\n'","+","inlist","+","'\\n'","# Otherwise we just put it back in the list.","else",":","items",".","insert","(","0",",","n_item",")","item","=","self",".","inline","(","item",")","item","=","open_tag_li","+","item","+","close_tag_li","lines",".","append","(","item",")","return","'\\n'",".","join","(","lines",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1575-L1674"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.ol","parameters":"(self, text, liparameters=None, olparameters=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Build an ordered list.\n\n        This function basically just sets the <ol><\/ol> with the\n        right attributes, and then pass everything inside to \n        _build_li, which does the real tough recursive job.\n\n        ---\n        h1. Ordered lists\n\n        Ordered lists can be constructed this way:\n\n        pre. # Item number 1.\n        # Item number 2.\n        # Item number 3.\n\n        And you get:\n\n        pre. <ol>\n        <li>Item number 1.<\/li>\n        <li>Item number 2.<\/li>\n        <li>Item number 3.<\/li>\n        <\/ol>\n\n        If you want a list to \"break\" an extended block, you should\n        add a period after the hash. This is useful for writing \n        Python code:\n\n        pre.. bc[python].. #!\/usr\/bin\/env python\n\n        # This is a comment, not an ordered list!\n        # So this won't break the extended \"bc\".\n\n        p. Lists can be nested:\n\n        pre. # Item number 1.\n        ## Item number 1a.\n        ## Item number 1b.\n        # Item number 2.\n        ## Item number 2a.\n\n        Textile will transform this to:\n\n        pre. <ol>\n        <li>Item number 1.\n        <ol>\n        <li>Item number 1a.<\/li>\n        <li>Item number 1b.<\/li>\n        <\/ol>\n        <\/li>\n        <li>Item number 2.\n        <ol>\n        <li>Item number 2a.<\/li>\n        <\/ol>\n        <\/li>\n        <\/ol>\n\n        You can also mix ordered and unordered lists:\n\n        pre. * To write well you need:\n        *# to read every day\n        *# to write every day\n        *# and X\n\n        You'll get this:\n\n        pre. <ul>\n        <li>To write well you need:\n        <ol>\n        <li>to read every day<\/li>\n        <li>to write every day<\/li>\n        <li>and X<\/li>\n        <\/ol>\n        <\/li>\n        <\/ul>\n\n        To style a list, the parameters should go before the hash if you want\n        to set the attributes on the @<ol>@ tag:\n\n        pre. (class#id)# one\n        # two\n        # three\n\n        If you want to customize the firsr @<li>@ tag, apply the parameters\n        after the hash:\n\n        pre. #(class#id) one\n        # two\n        # three","docstring_summary":"Build an ordered list.","docstring_tokens":["Build","an","ordered","list","."],"function":"def ol(self, text, liparameters=None, olparameters=None, clear=None):\n        \"\"\"Build an ordered list.\n\n        This function basically just sets the <ol><\/ol> with the\n        right attributes, and then pass everything inside to \n        _build_li, which does the real tough recursive job.\n\n        ---\n        h1. Ordered lists\n\n        Ordered lists can be constructed this way:\n\n        pre. # Item number 1.\n        # Item number 2.\n        # Item number 3.\n\n        And you get:\n\n        pre. <ol>\n        <li>Item number 1.<\/li>\n        <li>Item number 2.<\/li>\n        <li>Item number 3.<\/li>\n        <\/ol>\n\n        If you want a list to \"break\" an extended block, you should\n        add a period after the hash. This is useful for writing \n        Python code:\n\n        pre.. bc[python].. #!\/usr\/bin\/env python\n\n        # This is a comment, not an ordered list!\n        # So this won't break the extended \"bc\".\n\n        p. Lists can be nested:\n\n        pre. # Item number 1.\n        ## Item number 1a.\n        ## Item number 1b.\n        # Item number 2.\n        ## Item number 2a.\n\n        Textile will transform this to:\n\n        pre. <ol>\n        <li>Item number 1.\n        <ol>\n        <li>Item number 1a.<\/li>\n        <li>Item number 1b.<\/li>\n        <\/ol>\n        <\/li>\n        <li>Item number 2.\n        <ol>\n        <li>Item number 2a.<\/li>\n        <\/ol>\n        <\/li>\n        <\/ol>\n\n        You can also mix ordered and unordered lists:\n\n        pre. * To write well you need:\n        *# to read every day\n        *# to write every day\n        *# and X\n\n        You'll get this:\n\n        pre. <ul>\n        <li>To write well you need:\n        <ol>\n        <li>to read every day<\/li>\n        <li>to write every day<\/li>\n        <li>and X<\/li>\n        <\/ol>\n        <\/li>\n        <\/ul>\n\n        To style a list, the parameters should go before the hash if you want\n        to set the attributes on the @<ol>@ tag:\n\n        pre. (class#id)# one\n        # two\n        # three\n\n        If you want to customize the firsr @<li>@ tag, apply the parameters\n        after the hash:\n\n        pre. #(class#id) one\n        # two\n        # three\n        \"\"\"\n        # Get the attributes.\n        olattributes = self.parse_params(olparameters, clear)\n        liattributes = self.parse_params(liparameters)\n\n        # Remove list depth.\n        if text.startswith('#'):\n            text = text[1:]\n\n        items = text.split('\\n#')\n\n        # Build the open tag.\n        open_tag = self.build_open_tag('ol', olattributes) + '\\n'\n\n        close_tag = '\\n<\/ol>'\n\n        # Build the list items.\n        text = self.build_li(items, liattributes)\n\n        return open_tag + text + close_tag","function_tokens":["def","ol","(","self",",","text",",","liparameters","=","None",",","olparameters","=","None",",","clear","=","None",")",":","# Get the attributes.","olattributes","=","self",".","parse_params","(","olparameters",",","clear",")","liattributes","=","self",".","parse_params","(","liparameters",")","# Remove list depth.","if","text",".","startswith","(","'#'",")",":","text","=","text","[","1",":","]","items","=","text",".","split","(","'\\n#'",")","# Build the open tag.","open_tag","=","self",".","build_open_tag","(","'ol'",",","olattributes",")","+","'\\n'","close_tag","=","'\\n<\/ol>'","# Build the list items.","text","=","self",".","build_li","(","items",",","liattributes",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1677-L1785"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.ul","parameters":"(self, text, liparameters=None, olparameters=None, clear=None)","argument_list":"","return_statement":"return open_tag + text + close_tag","docstring":"Build an unordered list.\n\n        This function basically just sets the <ul><\/ul> with the\n        right attributes, and then pass everything inside to \n        _build_li, which does the real tough recursive job.\n\n        ---\n        h1. Unordered lists\n\n        Unordered lists behave exactly like the ordered lists, and are\n        defined using a star:\n\n        pre. * Python\n        * Perl\n        * PHP\n\n        Becomes:\n\n        pre. <ul>\n        <li>Python<\/li>\n        <li>Perl<\/li>\n        <li><span class=\"caps\">PHP<\/span><\/li>\n        <\/ul>","docstring_summary":"Build an unordered list.","docstring_tokens":["Build","an","unordered","list","."],"function":"def ul(self, text, liparameters=None, olparameters=None, clear=None):\n        \"\"\"Build an unordered list.\n\n        This function basically just sets the <ul><\/ul> with the\n        right attributes, and then pass everything inside to \n        _build_li, which does the real tough recursive job.\n\n        ---\n        h1. Unordered lists\n\n        Unordered lists behave exactly like the ordered lists, and are\n        defined using a star:\n\n        pre. * Python\n        * Perl\n        * PHP\n\n        Becomes:\n\n        pre. <ul>\n        <li>Python<\/li>\n        <li>Perl<\/li>\n        <li><span class=\"caps\">PHP<\/span><\/li>\n        <\/ul>\n        \"\"\"\n        # Get the attributes.\n        olattributes = self.parse_params(olparameters, clear)\n        liattributes = self.parse_params(liparameters)\n\n        # Remove list depth.\n        if text.startswith('*'):\n            text = text[1:]\n\n        items = text.split('\\n*')\n\n        # Build the open tag.\n        open_tag = self.build_open_tag('ul', olattributes) + '\\n'\n\n        close_tag = '\\n<\/ul>'\n\n        # Build the list items.\n        text = self.build_li(items, liattributes)\n\n        return open_tag + text + close_tag","function_tokens":["def","ul","(","self",",","text",",","liparameters","=","None",",","olparameters","=","None",",","clear","=","None",")",":","# Get the attributes.","olattributes","=","self",".","parse_params","(","olparameters",",","clear",")","liattributes","=","self",".","parse_params","(","liparameters",")","# Remove list depth.","if","text",".","startswith","(","'*'",")",":","text","=","text","[","1",":","]","items","=","text",".","split","(","'\\n*'",")","# Build the open tag.","open_tag","=","self",".","build_open_tag","(","'ul'",",","olattributes",")","+","'\\n'","close_tag","=","'\\n<\/ul>'","# Build the list items.","text","=","self",".","build_li","(","items",",","liattributes",")","return","open_tag","+","text","+","close_tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1788-L1831"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.table","parameters":"(self, text, parameters=None, clear=None)","argument_list":"","return_statement":"return text","docstring":"Build a table.\n\n        To build a table we split the text in lines to get the\n        rows, and split the rows between '|' to get the individual\n        cells.\n\n        ---\n        h1. Tables\n\n        Making a simple table is as easy as possible:\n\n        pre. |a|b|c|\n        |1|2|3|\n\n        Will be processed into:\n\n        pre. <table>\n        <tr>\n        <td>a<\/td>\n        <td>b<\/td>\n        <td>c<\/td>\n        <\/tr>\n        <tr>\n        <td>1<\/td>\n        <td>2<\/td>\n        <td>3<\/td>\n        <\/tr>\n        <\/table>\n\n        If you want to customize the @<table>@ tag, you must use the\n        @table@ signature:\n\n        pre. table(class#id)[en]. |a|b|c|\n        |1|2|3|\n\n        To customize a row, apply the modifier _before_ the first @|@:\n\n        pre. table. (class)<>|a|b|c|\n        |1|2|3|\n\n        Individual cells can by customized by adding the parameters _after_\n        the @|@, proceded by a period and a space:\n\n        pre. |(#id). a|b|c|\n        |1|2|3|\n\n        The allowed modifiers are:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule. \n        (class) or (#id) or (class#id):A CSS(Cascading Style Sheets) class and\/or id attribute. \n        ( (one or more):Adds 1em of padding to the left for each '(' character. \n        ) (one or more):Adds 1em of padding to the right for each ')' character. \n        &lt;:Aligns to the left (floats to left for tables if combined with the ')' modifier). \n        &gt;:Aligns to the right (floats to right for tables if combined with the '(' modifier). \n        =:Aligns to center (sets left, right margins to 'auto' for tables). \n        &lt;&gt;:For cells only. Justifies text. \n        ^:For rows and cells only. Aligns to the top. \n        ~ (tilde):For rows and cells only. Aligns to the bottom. \n        _ (underscore):Can be applied to a table row or cell to indicate a header row or cell. \n        \\\\2 or \\\\3 or \\\\4, etc.:Used within cells to indicate a colspan of 2, 3, 4, etc. columns. When you see \"\\\\\", think \"push forward\". \n        \/2 or \/3 or \/4, etc.:Used within cells to indicate a rowspan of 2, 3, 4, etc. rows. When you see \"\/\", think \"push downward\". \n        \n        When a cell is identified as a header cell and an alignment is\n        specified, that becomes the default alignment for cells below it.\n        You can always override this behavior by specifying an alignment\n        for one of the lower cells.","docstring_summary":"Build a table.","docstring_tokens":["Build","a","table","."],"function":"def table(self, text, parameters=None, clear=None):\n        \"\"\"Build a table.\n\n        To build a table we split the text in lines to get the\n        rows, and split the rows between '|' to get the individual\n        cells.\n\n        ---\n        h1. Tables\n\n        Making a simple table is as easy as possible:\n\n        pre. |a|b|c|\n        |1|2|3|\n\n        Will be processed into:\n\n        pre. <table>\n        <tr>\n        <td>a<\/td>\n        <td>b<\/td>\n        <td>c<\/td>\n        <\/tr>\n        <tr>\n        <td>1<\/td>\n        <td>2<\/td>\n        <td>3<\/td>\n        <\/tr>\n        <\/table>\n\n        If you want to customize the @<table>@ tag, you must use the\n        @table@ signature:\n\n        pre. table(class#id)[en]. |a|b|c|\n        |1|2|3|\n\n        To customize a row, apply the modifier _before_ the first @|@:\n\n        pre. table. (class)<>|a|b|c|\n        |1|2|3|\n\n        Individual cells can by customized by adding the parameters _after_\n        the @|@, proceded by a period and a space:\n\n        pre. |(#id). a|b|c|\n        |1|2|3|\n\n        The allowed modifiers are:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule. \n        (class) or (#id) or (class#id):A CSS(Cascading Style Sheets) class and\/or id attribute. \n        ( (one or more):Adds 1em of padding to the left for each '(' character. \n        ) (one or more):Adds 1em of padding to the right for each ')' character. \n        &lt;:Aligns to the left (floats to left for tables if combined with the ')' modifier). \n        &gt;:Aligns to the right (floats to right for tables if combined with the '(' modifier). \n        =:Aligns to center (sets left, right margins to 'auto' for tables). \n        &lt;&gt;:For cells only. Justifies text. \n        ^:For rows and cells only. Aligns to the top. \n        ~ (tilde):For rows and cells only. Aligns to the bottom. \n        _ (underscore):Can be applied to a table row or cell to indicate a header row or cell. \n        \\\\2 or \\\\3 or \\\\4, etc.:Used within cells to indicate a colspan of 2, 3, 4, etc. columns. When you see \"\\\\\", think \"push forward\". \n        \/2 or \/3 or \/4, etc.:Used within cells to indicate a rowspan of 2, 3, 4, etc. rows. When you see \"\/\", think \"push downward\". \n        \n        When a cell is identified as a header cell and an alignment is\n        specified, that becomes the default alignment for cells below it.\n        You can always override this behavior by specifying an alignment\n        for one of the lower cells.\n        \"\"\"\n        attributes = self.parse_params(parameters, clear, align_type='table')\n        #attributes['cellspacing'] = '0'\n\n        # Build the <table>.\n        open_tag = self.build_open_tag('table', attributes) + '\\n'\n        close_tag = '<\/table>'\n\n        output = []\n        default_align = {}\n        rows = re.split(r'''\\n+''', text)\n        for row in rows:\n            # Get the columns.\n            columns = row.split('|')\n\n            # Build the <tr>.\n            parameters = columns.pop(0)\n\n            rowattr = self.parse_params(parameters, align_type='table')\n            open_tr = self.build_open_tag('tr', rowattr) + '\\n'\n            output.append(open_tr)\n\n            # Does the row define headers?\n            if parameters.count('_'):\n                td_tag = 'th'\n            else:\n                td_tag = 'td'\n                \n            col = 0\n            for cell in columns[:-1]:\n                p = re.compile(r'''(?:%(tattr)s\\.\\s)?(?P<text>.*)''' % self.res, re.VERBOSE)\n                m = p.match(cell)\n                if m:\n                    c = m.groupdict('')\n                    cellattr = self.parse_params(c['parameters'], align_type='table')\n\n                    # Get the width of this cell.\n                    width = cellattr.get('colspan', 1)\n\n                    # Is this a header?\n                    if c['parameters'].count('_'):\n                        td_tag = 'th'\n\n                    # If it is a header, let's set the default alignment.\n                    if td_tag == 'th':\n                        # Set the default aligment for all cells below this one.\n                        # This is a little tricky because this header can have\n                        # a colspan set.\n                        for i in range(col, col+width):\n                            default_align[i] = cellattr.get('align', None)\n\n                    else:\n                        # Apply the default align, if any.\n                        cellattr['align'] = cellattr.get('align', default_align.get(col, None))\n\n                    open_td = self.build_open_tag(td_tag, cellattr)\n                    close_td = '<\/%s>\\n' % td_tag\n\n                    #output.append(open_td + c['text'].strip() + close_td)\n                    output.append(open_td + self.inline(c['text'].strip()) + close_td)\n\n                col += width\n\n            output.append('<\/tr>\\n')\n\n        text = open_tag + ''.join(output) + close_tag\n\n        return text","function_tokens":["def","table","(","self",",","text",",","parameters","=","None",",","clear","=","None",")",":","attributes","=","self",".","parse_params","(","parameters",",","clear",",","align_type","=","'table'",")","#attributes['cellspacing'] = '0'","# Build the <table>.","open_tag","=","self",".","build_open_tag","(","'table'",",","attributes",")","+","'\\n'","close_tag","=","'<\/table>'","output","=","[","]","default_align","=","{","}","rows","=","re",".","split","(","r'''\\n+'''",",","text",")","for","row","in","rows",":","# Get the columns.","columns","=","row",".","split","(","'|'",")","# Build the <tr>.","parameters","=","columns",".","pop","(","0",")","rowattr","=","self",".","parse_params","(","parameters",",","align_type","=","'table'",")","open_tr","=","self",".","build_open_tag","(","'tr'",",","rowattr",")","+","'\\n'","output",".","append","(","open_tr",")","# Does the row define headers?","if","parameters",".","count","(","'_'",")",":","td_tag","=","'th'","else",":","td_tag","=","'td'","col","=","0","for","cell","in","columns","[",":","-","1","]",":","p","=","re",".","compile","(","r'''(?:%(tattr)s\\.\\s)?(?P<text>.*)'''","%","self",".","res",",","re",".","VERBOSE",")","m","=","p",".","match","(","cell",")","if","m",":","c","=","m",".","groupdict","(","''",")","cellattr","=","self",".","parse_params","(","c","[","'parameters'","]",",","align_type","=","'table'",")","# Get the width of this cell.","width","=","cellattr",".","get","(","'colspan'",",","1",")","# Is this a header?","if","c","[","'parameters'","]",".","count","(","'_'",")",":","td_tag","=","'th'","# If it is a header, let's set the default alignment.","if","td_tag","==","'th'",":","# Set the default aligment for all cells below this one.","# This is a little tricky because this header can have","# a colspan set.","for","i","in","range","(","col",",","col","+","width",")",":","default_align","[","i","]","=","cellattr",".","get","(","'align'",",","None",")","else",":","# Apply the default align, if any.","cellattr","[","'align'","]","=","cellattr",".","get","(","'align'",",","default_align",".","get","(","col",",","None",")",")","open_td","=","self",".","build_open_tag","(","td_tag",",","cellattr",")","close_td","=","'<\/%s>\\n'","%","td_tag","#output.append(open_td + c['text'].strip() + close_td)","output",".","append","(","open_td","+","self",".","inline","(","c","[","'text'","]",".","strip","(",")",")","+","close_td",")","col","+=","width","output",".","append","(","'<\/tr>\\n'",")","text","=","open_tag","+","''",".","join","(","output",")","+","close_tag","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1834-L1968"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.escape","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Do nothing.\n\n        This is used to match escaped text. Nothing to see here!\n\n        ---\n        h1. Escaping\n\n        If you don't want Textile processing a block, you can simply\n        enclose it inside @==@:\n\n        pre. p. Regular paragraph\n\n        pre. ==\n        Escaped portion -- will not be formatted\n        by Textile at all\n        ==\n\n        pre. p. Back to normal.\n\n        This can also be used inline, disabling the formatting temporarily:\n\n        pre. p. This is ==*a test*== of escaping.","docstring_summary":"Do nothing.","docstring_tokens":["Do","nothing","."],"function":"def escape(self, text):\n        \"\"\"Do nothing.\n\n        This is used to match escaped text. Nothing to see here!\n\n        ---\n        h1. Escaping\n\n        If you don't want Textile processing a block, you can simply\n        enclose it inside @==@:\n\n        pre. p. Regular paragraph\n\n        pre. ==\n        Escaped portion -- will not be formatted\n        by Textile at all\n        ==\n\n        pre. p. Back to normal.\n\n        This can also be used inline, disabling the formatting temporarily:\n\n        pre. p. This is ==*a test*== of escaping.\n        \"\"\"\n        return text","function_tokens":["def","escape","(","self",",","text",")",":","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1971-L1995"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.itex","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Convert itex to MathML.\n\n        If the itex2mml binary is set, we use it to convert the\n        itex to MathML. Otherwise, the text is unprocessed and \n        return as is.\n\n        ---\n        h1. itex\n\n        Textile can automatically convert itex code to MathML(Mathematical Markup Language)\n        for you, if you have the itex2MML binary (you can download it\n        from the \"Movable Type plugin\":http:\/\/golem.ph.utexas.edu\/~distler\/blog\/files\/itexToMML.tar.gz).\n\n        Block equations should be enclosed inbetween @\\[@ and @\\]@:\n\n        pre. \\[ e^{i\\pi} + 1 = 0 \\]\n\n        Will be translated to:\n\n        pre. <math xmlns='http:\/\/www.w3.org\/1998\/Math\/MathML' mode='display'>\n        <msup><mi>e<\/mi> <mrow><mi>i<\/mi>\n        <mi>&amp;pi;<\/mi><\/mrow><\/msup>\n        <mo>+<\/mo><mn>1<\/mn><mo>=<\/mo><mn>0<\/mn>\n        <\/math>\n\n        Equations can also be displayed inline:\n\n        pre. Euler's formula, $e^{i\\pi}+1=0$, ...\n\n        (Note that if you want to display MathML(Mathematical Markup Language)\n        your content must be served as @application\/xhtml+xml@, which is not\n        accepted by all browsers.)","docstring_summary":"Convert itex to MathML.","docstring_tokens":["Convert","itex","to","MathML","."],"function":"def itex(self, text):\n        \"\"\"Convert itex to MathML.\n\n        If the itex2mml binary is set, we use it to convert the\n        itex to MathML. Otherwise, the text is unprocessed and \n        return as is.\n\n        ---\n        h1. itex\n\n        Textile can automatically convert itex code to MathML(Mathematical Markup Language)\n        for you, if you have the itex2MML binary (you can download it\n        from the \"Movable Type plugin\":http:\/\/golem.ph.utexas.edu\/~distler\/blog\/files\/itexToMML.tar.gz).\n\n        Block equations should be enclosed inbetween @\\[@ and @\\]@:\n\n        pre. \\[ e^{i\\pi} + 1 = 0 \\]\n\n        Will be translated to:\n\n        pre. <math xmlns='http:\/\/www.w3.org\/1998\/Math\/MathML' mode='display'>\n        <msup><mi>e<\/mi> <mrow><mi>i<\/mi>\n        <mi>&amp;pi;<\/mi><\/mrow><\/msup>\n        <mo>+<\/mo><mn>1<\/mn><mo>=<\/mo><mn>0<\/mn>\n        <\/math>\n\n        Equations can also be displayed inline:\n\n        pre. Euler's formula, $e^{i\\pi}+1=0$, ...\n\n        (Note that if you want to display MathML(Mathematical Markup Language)\n        your content must be served as @application\/xhtml+xml@, which is not\n        accepted by all browsers.)\n        \"\"\"\n        if itex2mml:\n            try:\n                text = os.popen(\"echo '%s' | %s\" % (text, itex2mml)).read()\n            except:\n                pass\n\n        return text","function_tokens":["def","itex","(","self",",","text",")",":","if","itex2mml",":","try",":","text","=","os",".","popen","(","\"echo '%s' | %s\"","%","(","text",",","itex2mml",")",")",".","read","(",")","except",":","pass","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L1998-L2038"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.about","parameters":"(self, text=None)","argument_list":"","return_statement":"return about","docstring":"Show PyTextile's functionalities.\n\n        An introduction to PyTextile. Can be called when running the\n        main script or if you write the following line:\n\n            'tell me about textile.'\n\n        But keep it a secret!","docstring_summary":"Show PyTextile's functionalities.","docstring_tokens":["Show","PyTextile","s","functionalities","."],"function":"def about(self, text=None):\n        \"\"\"Show PyTextile's functionalities.\n\n        An introduction to PyTextile. Can be called when running the\n        main script or if you write the following line:\n\n            'tell me about textile.'\n\n        But keep it a secret!\n        \"\"\"\n\n        about = []\n        about.append(textile('h1. This is Textile', head_offset=self.head_offset))\n        about.append(textile(__doc__.split('---', 1)[1], head_offset=self.head_offset))\n\n        functions = [(self.split_text, 1),\n                     (self.paragraph,  2),\n                     (self.pre,        2),\n                     (self.bc,         2),\n                     (self.blockquote, 2),\n                     (self.dl,         2),\n                     (self.header,     2),\n                     (self.footnote,   2),\n                     (self.escape,     2),\n                     (self.itex,       2),\n                     (self.ol,         2),\n                     (self.ul,         2),\n                     (self.table,      2),\n                     (self.inline,     1),\n                     (self.qtags,      2),\n                     (self.glyphs,     2),\n                     (self.macros,     2),\n                     (self.acronym,    2),\n                     (self.images,     1),\n                     (self.links,      1),\n                     (self.sanitize,   1),\n                    ]\n\n        for function, offset in functions:\n            doc = function.__doc__.split('---', 1)[1]\n            doc = doc.split('\\n')\n            lines = []\n            for line in doc:\n                line = line.strip()\n                lines.append(line)\n                \n            doc = '\\n'.join(lines)\n            about.append(textile(doc, head_offset=self.head_offset+offset))\n\n        about = '\\n'.join(about)\n        about = about.replace('<br \/>', '')\n\n        return about","function_tokens":["def","about","(","self",",","text","=","None",")",":","about","=","[","]","about",".","append","(","textile","(","'h1. This is Textile'",",","head_offset","=","self",".","head_offset",")",")","about",".","append","(","textile","(","__doc__",".","split","(","'---'",",","1",")","[","1","]",",","head_offset","=","self",".","head_offset",")",")","functions","=","[","(","self",".","split_text",",","1",")",",","(","self",".","paragraph",",","2",")",",","(","self",".","pre",",","2",")",",","(","self",".","bc",",","2",")",",","(","self",".","blockquote",",","2",")",",","(","self",".","dl",",","2",")",",","(","self",".","header",",","2",")",",","(","self",".","footnote",",","2",")",",","(","self",".","escape",",","2",")",",","(","self",".","itex",",","2",")",",","(","self",".","ol",",","2",")",",","(","self",".","ul",",","2",")",",","(","self",".","table",",","2",")",",","(","self",".","inline",",","1",")",",","(","self",".","qtags",",","2",")",",","(","self",".","glyphs",",","2",")",",","(","self",".","macros",",","2",")",",","(","self",".","acronym",",","2",")",",","(","self",".","images",",","1",")",",","(","self",".","links",",","1",")",",","(","self",".","sanitize",",","1",")",",","]","for","function",",","offset","in","functions",":","doc","=","function",".","__doc__",".","split","(","'---'",",","1",")","[","1","]","doc","=","doc",".","split","(","'\\n'",")","lines","=","[","]","for","line","in","doc",":","line","=","line",".","strip","(",")","lines",".","append","(","line",")","doc","=","'\\n'",".","join","(","lines",")","about",".","append","(","textile","(","doc",",","head_offset","=","self",".","head_offset","+","offset",")",")","about","=","'\\n'",".","join","(","about",")","about","=","about",".","replace","(","'<br \/>'",",","''",")","return","about"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2041-L2093"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.acronym","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Process acronyms.\n\n        Acronyms can have letters in upper and lower caps, or even numbers,\n        provided that the numbers and upper caps are the same in the\n        abbreviation and in the description. For example:\n\n            XHTML(eXtensible HyperText Markup Language)\n            OPeNDAP(Open source Project for a Network Data Access Protocol)\n            L94(Levitus 94)\n\n        are all valid acronyms.\n\n        ---\n        h1. Acronyms\n\n        You can define acronyms in your text the following way:\n\n        pre. This is XHTML(eXtensible HyperText Markup Language).\n\n        The resulting code is:\n\n        pre. <p><acronym title=\"eXtensible HyperText Markup Language\"><span class=\"caps\">XHTML<\/span><\/acronym><\/p>\n\n        Acronyms can have letters in upper and lower caps, or even numbers,\n        provided that the numbers and upper caps are the same in the\n        abbreviation and in the description. For example:\n\n        pre. XHTML(eXtensible HyperText Markup Language)\n        OPeNDAP(Open source Project for a Network Data Access Protocol)\n        L94(Levitus 94)\n\n        are all valid acronyms.","docstring_summary":"Process acronyms.","docstring_tokens":["Process","acronyms","."],"function":"def acronym(self, text):\n        \"\"\"Process acronyms.\n\n        Acronyms can have letters in upper and lower caps, or even numbers,\n        provided that the numbers and upper caps are the same in the\n        abbreviation and in the description. For example:\n\n            XHTML(eXtensible HyperText Markup Language)\n            OPeNDAP(Open source Project for a Network Data Access Protocol)\n            L94(Levitus 94)\n\n        are all valid acronyms.\n\n        ---\n        h1. Acronyms\n\n        You can define acronyms in your text the following way:\n\n        pre. This is XHTML(eXtensible HyperText Markup Language).\n\n        The resulting code is:\n\n        pre. <p><acronym title=\"eXtensible HyperText Markup Language\"><span class=\"caps\">XHTML<\/span><\/acronym><\/p>\n\n        Acronyms can have letters in upper and lower caps, or even numbers,\n        provided that the numbers and upper caps are the same in the\n        abbreviation and in the description. For example:\n\n        pre. XHTML(eXtensible HyperText Markup Language)\n        OPeNDAP(Open source Project for a Network Data Access Protocol)\n        L94(Levitus 94)\n\n        are all valid acronyms.\n        \"\"\"\n        # Find the acronyms.\n        acronyms = r'''(?P<acronym>[\\w]+)\\((?P<definition>[^\\(\\)]+?)\\)'''\n\n        # Check all acronyms.\n        for acronym, definition in re.findall(acronyms, text):\n            caps_acronym = ''.join(re.findall('[A-Z\\d]+', acronym))\n            caps_definition = ''.join(re.findall('[A-Z\\d]+', definition))\n            if caps_acronym and caps_acronym == caps_definition:\n                text = text.replace('%s(%s)' % (acronym, definition), '<acronym title=\"%s\">%s<\/acronym>' % (definition, acronym))\n        \n        text = html_replace(r'''(^|\\s)([A-Z]{3,})\\b(?!\\()''', r'''\\1<span class=\"caps\">\\2<\/span>''', text)\n\n        return text","function_tokens":["def","acronym","(","self",",","text",")",":","# Find the acronyms.","acronyms","=","r'''(?P<acronym>[\\w]+)\\((?P<definition>[^\\(\\)]+?)\\)'''","# Check all acronyms.","for","acronym",",","definition","in","re",".","findall","(","acronyms",",","text",")",":","caps_acronym","=","''",".","join","(","re",".","findall","(","'[A-Z\\d]+'",",","acronym",")",")","caps_definition","=","''",".","join","(","re",".","findall","(","'[A-Z\\d]+'",",","definition",")",")","if","caps_acronym","and","caps_acronym","==","caps_definition",":","text","=","text",".","replace","(","'%s(%s)'","%","(","acronym",",","definition",")",",","'<acronym title=\"%s\">%s<\/acronym>'","%","(","definition",",","acronym",")",")","text","=","html_replace","(","r'''(^|\\s)([A-Z]{3,})\\b(?!\\()'''",",","r'''\\1<span class=\"caps\">\\2<\/span>'''",",","text",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2096-L2142"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.footnotes","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Add titles to footnotes references.\n\n        This function searches for footnotes references like this [1], and \n        adds a title to the link containing the first paragraph of the\n        footnote.","docstring_summary":"Add titles to footnotes references.","docstring_tokens":["Add","titles","to","footnotes","references","."],"function":"def footnotes(self, text):\n        \"\"\"Add titles to footnotes references.\n\n        This function searches for footnotes references like this [1], and \n        adds a title to the link containing the first paragraph of the\n        footnote.\n        \"\"\"\n        # Search for footnotes.\n        p = re.compile(r'''<p class=\"footnote\" id=\"fn(?P<n>\\d+)\"><sup>(?P=n)<\/sup>(?P<note>.*)<\/p>''')\n        for m in p.finditer(text):\n            n = m.group('n')\n            note = m.group('note').strip()\n\n            # Strip HTML from note.\n            note = re.sub('<.*?>', '', note)\n\n            # Add the title.\n            text = text.replace('<a href=\"#fn%s\">' % n, '<a href=\"#fn%s\" title=\"%s\">' % (n, note))\n\n        return text","function_tokens":["def","footnotes","(","self",",","text",")",":","# Search for footnotes.","p","=","re",".","compile","(","r'''<p class=\"footnote\" id=\"fn(?P<n>\\d+)\"><sup>(?P=n)<\/sup>(?P<note>.*)<\/p>'''",")","for","m","in","p",".","finditer","(","text",")",":","n","=","m",".","group","(","'n'",")","note","=","m",".","group","(","'note'",")",".","strip","(",")","# Strip HTML from note.","note","=","re",".","sub","(","'<.*?>'",",","''",",","note",")","# Add the title.","text","=","text",".","replace","(","'<a href=\"#fn%s\">'","%","n",",","'<a href=\"#fn%s\" title=\"%s\">'","%","(","n",",","note",")",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2145-L2164"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.macros","parameters":"(self, m)","argument_list":"","return_statement":"return entity","docstring":"Quick macros.\n\n        This function replaces macros inside brackets using a built-in\n        dictionary, and also unicode names if the key doesn't exist.\n\n        ---\n        h1. Macros\n\n        Textile has support for character macros, which should be enclosed\n        in curly braces. A few useful ones are:\n\n        pre. {C=} or {=C}: euro sign\n        {+-} or {-+}: plus-minus sign\n        {L-} or {-L}: pound sign.\n\n        You can also make accented characters:\n\n        pre. Expos{e'}\n\n        Becomes:\n\n        pre. <p>Expos&amp;#233;<\/p>\n\n        You can also specify Unicode names like:\n\n        pre. {umbrella}\n        {white smiling face}","docstring_summary":"Quick macros.","docstring_tokens":["Quick","macros","."],"function":"def macros(self, m):\n        \"\"\"Quick macros.\n\n        This function replaces macros inside brackets using a built-in\n        dictionary, and also unicode names if the key doesn't exist.\n\n        ---\n        h1. Macros\n\n        Textile has support for character macros, which should be enclosed\n        in curly braces. A few useful ones are:\n\n        pre. {C=} or {=C}: euro sign\n        {+-} or {-+}: plus-minus sign\n        {L-} or {-L}: pound sign.\n\n        You can also make accented characters:\n\n        pre. Expos{e'}\n\n        Becomes:\n\n        pre. <p>Expos&amp;#233;<\/p>\n\n        You can also specify Unicode names like:\n\n        pre. {umbrella}\n        {white smiling face}\n        \"\"\"\n        entity = m.group(1)\n\n        macros = {'c|': '&#162;',       # cent sign\n                  '|c': '&#162;',       # cent sign\n                  'L-': '&#163;',       # pound sign\n                  '-L': '&#163;',       # pound sign\n                  'Y=': '&#165;',       # yen sign\n                  '=Y': '&#165;',       # yen sign\n                  '(c)': '&#169;',      # copyright sign\n                  '<<': '&#171;',       # left-pointing double angle quotation\n                  '(r)': '&#174;',      # registered sign\n                  '+_': '&#177;',       # plus-minus sign\n                  '_+': '&#177;',       # plus-minus sign\n                  '>>': '&#187;',       # right-pointing double angle quotation\n                  '1\/4': '&#188;',      # vulgar fraction one quarter\n                  '1\/2': '&#189;',      # vulgar fraction one half\n                  '3\/4': '&#190;',      # vulgar fraction three quarters\n                  'A`': '&#192;',       # latin capital letter a with grave\n                  '`A': '&#192;',       # latin capital letter a with grave\n                  'A\\'': '&#193;',      # latin capital letter a with acute\n                  '\\'A': '&#193;',      # latin capital letter a with acute\n                  'A^': '&#194;',       # latin capital letter a with circumflex\n                  '^A': '&#194;',       # latin capital letter a with circumflex\n                  'A~': '&#195;',       # latin capital letter a with tilde\n                  '~A': '&#195;',       # latin capital letter a with tilde\n                  'A\"': '&#196;',       # latin capital letter a with diaeresis\n                  '\"A': '&#196;',       # latin capital letter a with diaeresis\n                  'Ao': '&#197;',       # latin capital letter a with ring above\n                  'oA': '&#197;',       # latin capital letter a with ring above\n                  'AE': '&#198;',       # latin capital letter ae\n                  'C,': '&#199;',       # latin capital letter c with cedilla\n                  ',C': '&#199;',       # latin capital letter c with cedilla\n                  'E`': '&#200;',       # latin capital letter e with grave\n                  '`E': '&#200;',       # latin capital letter e with grave\n                  'E\\'': '&#201;',      # latin capital letter e with acute\n                  '\\'E': '&#201;',      # latin capital letter e with acute\n                  'E^': '&#202;',       # latin capital letter e with circumflex\n                  '^E': '&#202;',       # latin capital letter e with circumflex\n                  'E\"': '&#203;',       # latin capital letter e with diaeresis\n                  '\"E': '&#203;',       # latin capital letter e with diaeresis\n                  'I`': '&#204;',       # latin capital letter i with grave\n                  '`I': '&#204;',       # latin capital letter i with grave\n                  'I\\'': '&#205;',      # latin capital letter i with acute\n                  '\\'I': '&#205;',      # latin capital letter i with acute\n                  'I^': '&#206;',       # latin capital letter i with circumflex\n                  '^I': '&#206;',       # latin capital letter i with circumflex\n                  'I\"': '&#207;',       # latin capital letter i with diaeresis\n                  '\"I': '&#207;',       # latin capital letter i with diaeresis\n                  'D-': '&#208;',       # latin capital letter eth\n                  '-D': '&#208;',       # latin capital letter eth\n                  'N~': '&#209;',       # latin capital letter n with tilde\n                  '~N': '&#209;',       # latin capital letter n with tilde\n                  'O`': '&#210;',       # latin capital letter o with grave\n                  '`O': '&#210;',       # latin capital letter o with grave\n                  'O\\'': '&#211;',      # latin capital letter o with acute\n                  '\\'O': '&#211;',      # latin capital letter o with acute\n                  'O^': '&#212;',       # latin capital letter o with circumflex\n                  '^O': '&#212;',       # latin capital letter o with circumflex\n                  'O~': '&#213;',       # latin capital letter o with tilde\n                  '~O': '&#213;',       # latin capital letter o with tilde\n                  'O\"': '&#214;',       # latin capital letter o with diaeresis\n                  '\"O': '&#214;',       # latin capital letter o with diaeresis\n                  'O\/': '&#216;',       # latin capital letter o with stroke\n                  '\/O': '&#216;',       # latin capital letter o with stroke\n                  'U`':  '&#217;',      # latin capital letter u with grave\n                  '`U':  '&#217;',      # latin capital letter u with grave\n                  'U\\'': '&#218;',      # latin capital letter u with acute\n                  '\\'U': '&#218;',      # latin capital letter u with acute\n                  'U^': '&#219;',       # latin capital letter u with circumflex\n                  '^U': '&#219;',       # latin capital letter u with circumflex\n                  'U\"': '&#220;',       # latin capital letter u with diaeresis\n                  '\"U': '&#220;',       # latin capital letter u with diaeresis\n                  'Y\\'': '&#221;',      # latin capital letter y with acute\n                  '\\'Y': '&#221;',      # latin capital letter y with acute\n                  'a`': '&#224;',       # latin small letter a with grave\n                  '`a': '&#224;',       # latin small letter a with grave\n                  'a\\'': '&#225;',      # latin small letter a with acute\n                  '\\'a': '&#225;',      # latin small letter a with acute\n                  'a^': '&#226;',       # latin small letter a with circumflex\n                  '^a': '&#226;',       # latin small letter a with circumflex\n                  'a~': '&#227;',       # latin small letter a with tilde\n                  '~a': '&#227;',       # latin small letter a with tilde\n                  'a\"': '&#228;',       # latin small letter a with diaeresis\n                  '\"a': '&#228;',       # latin small letter a with diaeresis\n                  'ao': '&#229;',       # latin small letter a with ring above\n                  'oa': '&#229;',       # latin small letter a with ring above\n                  'ae': '&#230;',       # latin small letter ae\n                  'c,': '&#231;',       # latin small letter c with cedilla\n                  ',c': '&#231;',       # latin small letter c with cedilla\n                  'e`': '&#232;',       # latin small letter e with grave\n                  '`e': '&#232;',       # latin small letter e with grave\n                  'e\\'': '&#233;',      # latin small letter e with acute\n                  '\\'e': '&#233;',      # latin small letter e with acute\n                  'e^': '&#234;',       # latin small letter e with circumflex\n                  '^e': '&#234;',       # latin small letter e with circumflex\n                  'e\"': '&#235;',       # latin small letter e with diaeresis\n                  '\"e': '&#235;',       # latin small letter e with diaeresis\n                  'i`': '&#236;',       # latin small letter i with grave\n                  '`i': '&#236;',       # latin small letter i with grave\n                  'i\\'': '&#237;',      # latin small letter i with acute\n                  '\\'i': '&#237;',      # latin small letter i with acute\n                  'i^': '&#238;',       # latin small letter i with circumflex\n                  '^i': '&#238;',       # latin small letter i with circumflex\n                  'i\"': '&#239;',       # latin small letter i with diaeresis\n                  '\"i': '&#239;',       # latin small letter i with diaeresis\n                  'n~': '&#241;',       # latin small letter n with tilde\n                  '~n': '&#241;',       # latin small letter n with tilde\n                  'o`': '&#242;',       # latin small letter o with grave\n                  '`o': '&#242;',       # latin small letter o with grave\n                  'o\\'': '&#243;',      # latin small letter o with acute\n                  '\\'o': '&#243;',      # latin small letter o with acute\n                  'o^': '&#244;',       # latin small letter o with circumflex\n                  '^o': '&#244;',       # latin small letter o with circumflex\n                  'o~': '&#245;',       # latin small letter o with tilde\n                  '~o': '&#245;',       # latin small letter o with tilde\n                  'o\"': '&#246;',       # latin small letter o with diaeresis\n                  '\"o': '&#246;',       # latin small letter o with diaeresis\n                  ':-': '&#247;',       # division sign\n                  '-:': '&#247;',       # division sign\n                  'o\/': '&#248;',       # latin small letter o with stroke\n                  '\/o': '&#248;',       # latin small letter o with stroke\n                  'u`': '&#249;',       # latin small letter u with grave\n                  '`u': '&#249;',       # latin small letter u with grave\n                  'u\\'': '&#250;',      # latin small letter u with acute\n                  '\\'u': '&#250;',      # latin small letter u with acute\n                  'u^': '&#251;',       # latin small letter u with circumflex\n                  '^u': '&#251;',       # latin small letter u with circumflex\n                  'u\"': '&#252;',       # latin small letter u with diaeresis\n                  '\"u': '&#252;',       # latin small letter u with diaeresis\n                  'y\\'': '&#253;',      # latin small letter y with acute\n                  '\\'y': '&#253;',      # latin small letter y with acute\n                  'y\"': '&#255',        # latin small letter y with diaeresis\n                  '\"y': '&#255',        # latin small letter y with diaeresis\n                  'OE': '&#338;',       # latin capital ligature oe\n                  'oe': '&#339;',       # latin small ligature oe\n                  '*': '&#8226;',       # bullet\n                  'Fr': '&#8355;',      # french franc sign\n                  'L=': '&#8356;',      # lira sign\n                  '=L': '&#8356;',      # lira sign\n                  'Rs': '&#8360;',      # rupee sign\n                  'C=': '&#8364;',      # euro sign\n                  '=C': '&#8364;',      # euro sign\n                  'tm': '&#8482;',      # trade mark sign\n                  '<-': '&#8592;',      # leftwards arrow\n                  '->': '&#8594;',      # rightwards arrow\n                  '<=': '&#8656;',      # leftwards double arrow\n                  '=>': '&#8658;',      # rightwards double arrow\n                  '=\/': '&#8800;',      # not equal to\n                  '\/=': '&#8800;',      # not equal to\n                  '<_': '&#8804;',      # less-than or equal to\n                  '_<': '&#8804;',      # less-than or equal to\n                  '>_': '&#8805;',      # greater-than or equal to\n                  '_>': '&#8805;',      # greater-than or equal to\n                  ':(': '&#9785;',      # white frowning face\n                  ':)': '&#9786;',      # white smiling face\n                  'spade': '&#9824;',   # black spade suit\n                  'club': '&#9827;',    # black club suit\n                  'heart': '&#9829;',   # black heart suit\n                  'diamond': '&#9830;', # black diamond suit\n                 }\n\n        try:\n            # Try the key.\n            entity = macros[entity]\n        except KeyError:\n            try:\n                # Try a unicode entity.\n                entity = unicodedata.lookup(entity)\n                entity = entity.encode('ascii', 'xmlcharrefreplace')\n            except:\n                # Return the unmodified entity.\n                entity = '{%s}' % entity\n\n        return entity","function_tokens":["def","macros","(","self",",","m",")",":","entity","=","m",".","group","(","1",")","macros","=","{","'c|'",":","'&#162;'",",","# cent sign","'|c'",":","'&#162;'",",","# cent sign","'L-'",":","'&#163;'",",","# pound sign","'-L'",":","'&#163;'",",","# pound sign","'Y='",":","'&#165;'",",","# yen sign","'=Y'",":","'&#165;'",",","# yen sign","'(c)'",":","'&#169;'",",","# copyright sign","'<<'",":","'&#171;'",",","# left-pointing double angle quotation","'(r)'",":","'&#174;'",",","# registered sign","'+_'",":","'&#177;'",",","# plus-minus sign","'_+'",":","'&#177;'",",","# plus-minus sign","'>>'",":","'&#187;'",",","# right-pointing double angle quotation","'1\/4'",":","'&#188;'",",","# vulgar fraction one quarter","'1\/2'",":","'&#189;'",",","# vulgar fraction one half","'3\/4'",":","'&#190;'",",","# vulgar fraction three quarters","'A`'",":","'&#192;'",",","# latin capital letter a with grave","'`A'",":","'&#192;'",",","# latin capital letter a with grave","'A\\''",":","'&#193;'",",","# latin capital letter a with acute","'\\'A'",":","'&#193;'",",","# latin capital letter a with acute","'A^'",":","'&#194;'",",","# latin capital letter a with circumflex","'^A'",":","'&#194;'",",","# latin capital letter a with circumflex","'A~'",":","'&#195;'",",","# latin capital letter a with tilde","'~A'",":","'&#195;'",",","# latin capital letter a with tilde","'A\"'",":","'&#196;'",",","# latin capital letter a with diaeresis","'\"A'",":","'&#196;'",",","# latin capital letter a with diaeresis","'Ao'",":","'&#197;'",",","# latin capital letter a with ring above","'oA'",":","'&#197;'",",","# latin capital letter a with ring above","'AE'",":","'&#198;'",",","# latin capital letter ae","'C,'",":","'&#199;'",",","# latin capital letter c with cedilla","',C'",":","'&#199;'",",","# latin capital letter c with cedilla","'E`'",":","'&#200;'",",","# latin capital letter e with grave","'`E'",":","'&#200;'",",","# latin capital letter e with grave","'E\\''",":","'&#201;'",",","# latin capital letter e with acute","'\\'E'",":","'&#201;'",",","# latin capital letter e with acute","'E^'",":","'&#202;'",",","# latin capital letter e with circumflex","'^E'",":","'&#202;'",",","# latin capital letter e with circumflex","'E\"'",":","'&#203;'",",","# latin capital letter e with diaeresis","'\"E'",":","'&#203;'",",","# latin capital letter e with diaeresis","'I`'",":","'&#204;'",",","# latin capital letter i with grave","'`I'",":","'&#204;'",",","# latin capital letter i with grave","'I\\''",":","'&#205;'",",","# latin capital letter i with acute","'\\'I'",":","'&#205;'",",","# latin capital letter i with acute","'I^'",":","'&#206;'",",","# latin capital letter i with circumflex","'^I'",":","'&#206;'",",","# latin capital letter i with circumflex","'I\"'",":","'&#207;'",",","# latin capital letter i with diaeresis","'\"I'",":","'&#207;'",",","# latin capital letter i with diaeresis","'D-'",":","'&#208;'",",","# latin capital letter eth","'-D'",":","'&#208;'",",","# latin capital letter eth","'N~'",":","'&#209;'",",","# latin capital letter n with tilde","'~N'",":","'&#209;'",",","# latin capital letter n with tilde","'O`'",":","'&#210;'",",","# latin capital letter o with grave","'`O'",":","'&#210;'",",","# latin capital letter o with grave","'O\\''",":","'&#211;'",",","# latin capital letter o with acute","'\\'O'",":","'&#211;'",",","# latin capital letter o with acute","'O^'",":","'&#212;'",",","# latin capital letter o with circumflex","'^O'",":","'&#212;'",",","# latin capital letter o with circumflex","'O~'",":","'&#213;'",",","# latin capital letter o with tilde","'~O'",":","'&#213;'",",","# latin capital letter o with tilde","'O\"'",":","'&#214;'",",","# latin capital letter o with diaeresis","'\"O'",":","'&#214;'",",","# latin capital letter o with diaeresis","'O\/'",":","'&#216;'",",","# latin capital letter o with stroke","'\/O'",":","'&#216;'",",","# latin capital letter o with stroke","'U`'",":","'&#217;'",",","# latin capital letter u with grave","'`U'",":","'&#217;'",",","# latin capital letter u with grave","'U\\''",":","'&#218;'",",","# latin capital letter u with acute","'\\'U'",":","'&#218;'",",","# latin capital letter u with acute","'U^'",":","'&#219;'",",","# latin capital letter u with circumflex","'^U'",":","'&#219;'",",","# latin capital letter u with circumflex","'U\"'",":","'&#220;'",",","# latin capital letter u with diaeresis","'\"U'",":","'&#220;'",",","# latin capital letter u with diaeresis","'Y\\''",":","'&#221;'",",","# latin capital letter y with acute","'\\'Y'",":","'&#221;'",",","# latin capital letter y with acute","'a`'",":","'&#224;'",",","# latin small letter a with grave","'`a'",":","'&#224;'",",","# latin small letter a with grave","'a\\''",":","'&#225;'",",","# latin small letter a with acute","'\\'a'",":","'&#225;'",",","# latin small letter a with acute","'a^'",":","'&#226;'",",","# latin small letter a with circumflex","'^a'",":","'&#226;'",",","# latin small letter a with circumflex","'a~'",":","'&#227;'",",","# latin small letter a with tilde","'~a'",":","'&#227;'",",","# latin small letter a with tilde","'a\"'",":","'&#228;'",",","# latin small letter a with diaeresis","'\"a'",":","'&#228;'",",","# latin small letter a with diaeresis","'ao'",":","'&#229;'",",","# latin small letter a with ring above","'oa'",":","'&#229;'",",","# latin small letter a with ring above","'ae'",":","'&#230;'",",","# latin small letter ae","'c,'",":","'&#231;'",",","# latin small letter c with cedilla","',c'",":","'&#231;'",",","# latin small letter c with cedilla","'e`'",":","'&#232;'",",","# latin small letter e with grave","'`e'",":","'&#232;'",",","# latin small letter e with grave","'e\\''",":","'&#233;'",",","# latin small letter e with acute","'\\'e'",":","'&#233;'",",","# latin small letter e with acute","'e^'",":","'&#234;'",",","# latin small letter e with circumflex","'^e'",":","'&#234;'",",","# latin small letter e with circumflex","'e\"'",":","'&#235;'",",","# latin small letter e with diaeresis","'\"e'",":","'&#235;'",",","# latin small letter e with diaeresis","'i`'",":","'&#236;'",",","# latin small letter i with grave","'`i'",":","'&#236;'",",","# latin small letter i with grave","'i\\''",":","'&#237;'",",","# latin small letter i with acute","'\\'i'",":","'&#237;'",",","# latin small letter i with acute","'i^'",":","'&#238;'",",","# latin small letter i with circumflex","'^i'",":","'&#238;'",",","# latin small letter i with circumflex","'i\"'",":","'&#239;'",",","# latin small letter i with diaeresis","'\"i'",":","'&#239;'",",","# latin small letter i with diaeresis","'n~'",":","'&#241;'",",","# latin small letter n with tilde","'~n'",":","'&#241;'",",","# latin small letter n with tilde","'o`'",":","'&#242;'",",","# latin small letter o with grave","'`o'",":","'&#242;'",",","# latin small letter o with grave","'o\\''",":","'&#243;'",",","# latin small letter o with acute","'\\'o'",":","'&#243;'",",","# latin small letter o with acute","'o^'",":","'&#244;'",",","# latin small letter o with circumflex","'^o'",":","'&#244;'",",","# latin small letter o with circumflex","'o~'",":","'&#245;'",",","# latin small letter o with tilde","'~o'",":","'&#245;'",",","# latin small letter o with tilde","'o\"'",":","'&#246;'",",","# latin small letter o with diaeresis","'\"o'",":","'&#246;'",",","# latin small letter o with diaeresis","':-'",":","'&#247;'",",","# division sign","'-:'",":","'&#247;'",",","# division sign","'o\/'",":","'&#248;'",",","# latin small letter o with stroke","'\/o'",":","'&#248;'",",","# latin small letter o with stroke","'u`'",":","'&#249;'",",","# latin small letter u with grave","'`u'",":","'&#249;'",",","# latin small letter u with grave","'u\\''",":","'&#250;'",",","# latin small letter u with acute","'\\'u'",":","'&#250;'",",","# latin small letter u with acute","'u^'",":","'&#251;'",",","# latin small letter u with circumflex","'^u'",":","'&#251;'",",","# latin small letter u with circumflex","'u\"'",":","'&#252;'",",","# latin small letter u with diaeresis","'\"u'",":","'&#252;'",",","# latin small letter u with diaeresis","'y\\''",":","'&#253;'",",","# latin small letter y with acute","'\\'y'",":","'&#253;'",",","# latin small letter y with acute","'y\"'",":","'&#255'",",","# latin small letter y with diaeresis","'\"y'",":","'&#255'",",","# latin small letter y with diaeresis","'OE'",":","'&#338;'",",","# latin capital ligature oe","'oe'",":","'&#339;'",",","# latin small ligature oe","'*'",":","'&#8226;'",",","# bullet","'Fr'",":","'&#8355;'",",","# french franc sign","'L='",":","'&#8356;'",",","# lira sign","'=L'",":","'&#8356;'",",","# lira sign","'Rs'",":","'&#8360;'",",","# rupee sign","'C='",":","'&#8364;'",",","# euro sign","'=C'",":","'&#8364;'",",","# euro sign","'tm'",":","'&#8482;'",",","# trade mark sign","'<-'",":","'&#8592;'",",","# leftwards arrow","'->'",":","'&#8594;'",",","# rightwards arrow","'<='",":","'&#8656;'",",","# leftwards double arrow","'=>'",":","'&#8658;'",",","# rightwards double arrow","'=\/'",":","'&#8800;'",",","# not equal to","'\/='",":","'&#8800;'",",","# not equal to","'<_'",":","'&#8804;'",",","# less-than or equal to","'_<'",":","'&#8804;'",",","# less-than or equal to","'>_'",":","'&#8805;'",",","# greater-than or equal to","'_>'",":","'&#8805;'",",","# greater-than or equal to","':('",":","'&#9785;'",",","# white frowning face","':)'",":","'&#9786;'",",","# white smiling face","'spade'",":","'&#9824;'",",","# black spade suit","'club'",":","'&#9827;'",",","# black club suit","'heart'",":","'&#9829;'",",","# black heart suit","'diamond'",":","'&#9830;'",",","# black diamond suit","}","try",":","# Try the key.","entity","=","macros","[","entity","]","except","KeyError",":","try",":","# Try a unicode entity.","entity","=","unicodedata",".","lookup","(","entity",")","entity","=","entity",".","encode","(","'ascii'",",","'xmlcharrefreplace'",")","except",":","# Return the unmodified entity.","entity","=","'{%s}'","%","entity","return","entity"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2167-L2369"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.glyphs","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Glyph formatting.\n\n        This function replaces quotations marks, dashes and a few other\n        symbol for numerical entities. The em\/en dashes use definitions\n        comes from http:\/\/alistapart.com\/articles\/emen\/.\n\n        ---\n        h1. Glyphs\n\n        Textile replaces some of the characters in your text with their\n        equivalent numerical entities. These include:\n\n        * Replace single and double primes used as quotation marks with HTML(HyperText Markup Language) entities for opening and closing quotation marks in readable text, while leaving untouched the primes required within HTML(HyperText Markup Language) tags.\n        * Replace double hyphens (==--==) with an em-dash (&#8212;) entity.\n        * Replace triple hyphens (==---==) with two em-dash (&#8212;&#8212;) entities.\n        * Replace single hyphens surrounded by spaces with an en-dash (&#8211;) entity.\n        * Replace triplets of periods (==...==) with an ellipsis (&#8230;) entity.\n        * Convert many nonstandard characters to browser-safe entities corresponding to keyboard input.\n        * Convert ==(TM)==, ==(R)==, and  ==(C)== to &#8482;, &#174;, and &#169;.\n        * Convert the letter x to a dimension sign: 2==x==4 to 2x4 and 8 ==x== 10 to 8x10.","docstring_summary":"Glyph formatting.","docstring_tokens":["Glyph","formatting","."],"function":"def glyphs(self, text):\n        \"\"\"Glyph formatting.\n\n        This function replaces quotations marks, dashes and a few other\n        symbol for numerical entities. The em\/en dashes use definitions\n        comes from http:\/\/alistapart.com\/articles\/emen\/.\n\n        ---\n        h1. Glyphs\n\n        Textile replaces some of the characters in your text with their\n        equivalent numerical entities. These include:\n\n        * Replace single and double primes used as quotation marks with HTML(HyperText Markup Language) entities for opening and closing quotation marks in readable text, while leaving untouched the primes required within HTML(HyperText Markup Language) tags.\n        * Replace double hyphens (==--==) with an em-dash (&#8212;) entity.\n        * Replace triple hyphens (==---==) with two em-dash (&#8212;&#8212;) entities.\n        * Replace single hyphens surrounded by spaces with an en-dash (&#8211;) entity.\n        * Replace triplets of periods (==...==) with an ellipsis (&#8230;) entity.\n        * Convert many nonstandard characters to browser-safe entities corresponding to keyboard input.\n        * Convert ==(TM)==, ==(R)==, and  ==(C)== to &#8482;, &#174;, and &#169;.\n        * Convert the letter x to a dimension sign: 2==x==4 to 2x4 and 8 ==x== 10 to 8x10.\n        \"\"\"\n        glyphs = [(r'''\"(?<!\\w)\\b''', r'''&#8220;'''),                              # double quotes\n                  (r'''\"''', r'''&#8221;'''),                                       # double quotes\n                  (r\"\"\"\\b'\"\"\", r'''&#8217;'''),                                     # single quotes\n                  (r\"\"\"'(?<!\\w)\\b\"\"\", r'''&#8216;'''),                              # single quotes\n                  (r\"\"\"'\"\"\", r'''&#8217;'''),                                       # single single quote\n                  (r'''(\\b|^)( )?\\.{3}''', r'''\\1&#8230;'''),                       # ellipsis\n                  (r'''\\b---\\b''', r'''&#8212;&#8212;'''),                          # double em dash\n                  (r'''\\s?--\\s?''', r'''&#8212;'''),                                # em dash\n                  (r'''(\\d+)-(\\d+)''', r'''\\1&#8211;\\2'''),                         # en dash (1954-1999)\n                  (r'''(\\d+)-(\\W)''', r'''\\1&#8212;\\2'''),                          # em dash (1954--)\n                  (r'''\\s-\\s''', r''' &#8211; '''),                                 # en dash\n                  (r'''(\\d+) ?x ?(\\d+)''', r'''\\1&#215;\\2'''),                      # dimension sign\n                  (r'''\\b ?(\\((tm|TM)\\))''', r'''&#8482;'''),                       # trademark\n                  (r'''\\b ?(\\([rR]\\))''', r'''&#174;'''),                           # registered\n                  (r'''\\b ?(\\([cC]\\))''', r'''&#169;'''),                           # copyright\n                  (r'''([^\\s])\\[(\\d+)\\]''',                                         #\n                       r'''\\1<sup class=\"footnote\"><a href=\"#fn\\2\">\\2<\/a><\/sup>'''),# footnote\n                  ]\n\n        # Apply macros.\n        text = re.sub(r'''{([^}]+)}''', self.macros, text)\n\n        # LaTeX style quotes.\n        text = text.replace('\\x60\\x60', '&#8220;')\n        text = text.replace('\\xb4\\xb4', '&#8221;')\n\n        # Linkify URL and emails.\n        url = r'''(?=[a-zA-Z0-9.\/#])                          # Must start correctly\n                  ((?:                                        # Match the leading part (proto:\/\/hostname, or just hostname)\n                      (?:ftp|https?|telnet|nntp)              #     protocol\n                      :\/\/                                     #     :\/\/\n                      (?:                                     #     Optional 'username:password@'\n                          \\w+                                 #         username\n                          (?::\\w+)?                           #         optional :password\n                          @                                   #         @\n                      )?                                      # \n                      [-\\w]+(?:\\.\\w[-\\w]*)+                   #     hostname (sub.example.com)\n                  )                                           #\n                  (?::\\d+)?                                   # Optional port number\n                  (?:                                         # Rest of the URL, optional\n                      \/?                                      #     Start with '\/'\n                      [^.!,?;:\"'<>()\\[\\]{}\\s\\x7F-\\xFF]*       #     Can't start with these\n                      (?:                                     #\n                          [.!,?;:]+                           #     One or more of these\n                          [^.!,?;:\"'<>()\\[\\]{}\\s\\x7F-\\xFF]+   #     Can't finish with these\n                          #'\"                                 #     # or ' or \"\n                      )*                                      #\n                  )?)                                         #\n               '''\n\n        email = r'''(?:mailto:)?            # Optional mailto:\n                    ([-\\+\\w]+               # username\n                    \\@                      # at\n                    [-\\w]+(?:\\.\\w[-\\w]*)+)  # hostname\n                 '''\n\n        # If there is no html, do a simple search and replace.\n        if not re.search(r'''<.*>''', text):\n            for glyph_search, glyph_replace in glyphs:\n                text = preg_replace(glyph_search, glyph_replace, text)\n\n            # Linkify.\n            text = re.sub(re.compile(url, re.VERBOSE), r'''<a href=\"\\1\">\\1<\/a>''', text)\n            text = re.sub(re.compile(email, re.VERBOSE), r'''<a href=\"mailto:\\1\">\\1<\/a>''', text)\n\n        else:\n            lines = []\n            # Else split the text into an array at <>.\n            for line in re.split('(<.*?>)', text):\n                if not re.match('<.*?>', line):\n                    for glyph_search, glyph_replace in glyphs:\n                        line = preg_replace(glyph_search, glyph_replace, line)\n\n                    # Linkify.\n                    line = re.sub(re.compile(url, re.VERBOSE), r'''<a href=\"\\1\">\\1<\/a>''', line)\n                    line = re.sub(re.compile(email, re.VERBOSE), r'''<a href=\"mailto:\\1\">\\1<\/a>''', line)\n\n                lines.append(line)\n\n            text = ''.join(lines)\n\n        return text","function_tokens":["def","glyphs","(","self",",","text",")",":","glyphs","=","[","(","r'''\"(?<!\\w)\\b'''",",","r'''&#8220;'''",")",",","# double quotes","(","r'''\"'''",",","r'''&#8221;'''",")",",","# double quotes","(","r\"\"\"\\b'\"\"\"",",","r'''&#8217;'''",")",",","# single quotes","(","r\"\"\"'(?<!\\w)\\b\"\"\"",",","r'''&#8216;'''",")",",","# single quotes","(","r\"\"\"'\"\"\"",",","r'''&#8217;'''",")",",","# single single quote","(","r'''(\\b|^)( )?\\.{3}'''",",","r'''\\1&#8230;'''",")",",","# ellipsis","(","r'''\\b---\\b'''",",","r'''&#8212;&#8212;'''",")",",","# double em dash","(","r'''\\s?--\\s?'''",",","r'''&#8212;'''",")",",","# em dash","(","r'''(\\d+)-(\\d+)'''",",","r'''\\1&#8211;\\2'''",")",",","# en dash (1954-1999)","(","r'''(\\d+)-(\\W)'''",",","r'''\\1&#8212;\\2'''",")",",","# em dash (1954--)","(","r'''\\s-\\s'''",",","r''' &#8211; '''",")",",","# en dash","(","r'''(\\d+) ?x ?(\\d+)'''",",","r'''\\1&#215;\\2'''",")",",","# dimension sign","(","r'''\\b ?(\\((tm|TM)\\))'''",",","r'''&#8482;'''",")",",","# trademark","(","r'''\\b ?(\\([rR]\\))'''",",","r'''&#174;'''",")",",","# registered","(","r'''\\b ?(\\([cC]\\))'''",",","r'''&#169;'''",")",",","# copyright","(","r'''([^\\s])\\[(\\d+)\\]'''",",","#","r'''\\1<sup class=\"footnote\"><a href=\"#fn\\2\">\\2<\/a><\/sup>'''",")",",","# footnote","]","# Apply macros.","text","=","re",".","sub","(","r'''{([^}]+)}'''",",","self",".","macros",",","text",")","# LaTeX style quotes.","text","=","text",".","replace","(","'\\x60\\x60'",",","'&#8220;'",")","text","=","text",".","replace","(","'\\xb4\\xb4'",",","'&#8221;'",")","# Linkify URL and emails.","url","=","r'''(?=[a-zA-Z0-9.\/#])                          # Must start correctly\n                  ((?:                                        # Match the leading part (proto:\/\/hostname, or just hostname)\n                      (?:ftp|https?|telnet|nntp)              #     protocol\n                      :\/\/                                     #     :\/\/\n                      (?:                                     #     Optional 'username:password@'\n                          \\w+                                 #         username\n                          (?::\\w+)?                           #         optional :password\n                          @                                   #         @\n                      )?                                      # \n                      [-\\w]+(?:\\.\\w[-\\w]*)+                   #     hostname (sub.example.com)\n                  )                                           #\n                  (?::\\d+)?                                   # Optional port number\n                  (?:                                         # Rest of the URL, optional\n                      \/?                                      #     Start with '\/'\n                      [^.!,?;:\"'<>()\\[\\]{}\\s\\x7F-\\xFF]*       #     Can't start with these\n                      (?:                                     #\n                          [.!,?;:]+                           #     One or more of these\n                          [^.!,?;:\"'<>()\\[\\]{}\\s\\x7F-\\xFF]+   #     Can't finish with these\n                          #'\"                                 #     # or ' or \"\n                      )*                                      #\n                  )?)                                         #\n               '''","email","=","r'''(?:mailto:)?            # Optional mailto:\n                    ([-\\+\\w]+               # username\n                    \\@                      # at\n                    [-\\w]+(?:\\.\\w[-\\w]*)+)  # hostname\n                 '''","# If there is no html, do a simple search and replace.","if","not","re",".","search","(","r'''<.*>'''",",","text",")",":","for","glyph_search",",","glyph_replace","in","glyphs",":","text","=","preg_replace","(","glyph_search",",","glyph_replace",",","text",")","# Linkify.","text","=","re",".","sub","(","re",".","compile","(","url",",","re",".","VERBOSE",")",",","r'''<a href=\"\\1\">\\1<\/a>'''",",","text",")","text","=","re",".","sub","(","re",".","compile","(","email",",","re",".","VERBOSE",")",",","r'''<a href=\"mailto:\\1\">\\1<\/a>'''",",","text",")","else",":","lines","=","[","]","# Else split the text into an array at <>.","for","line","in","re",".","split","(","'(<.*?>)'",",","text",")",":","if","not","re",".","match","(","'<.*?>'",",","line",")",":","for","glyph_search",",","glyph_replace","in","glyphs",":","line","=","preg_replace","(","glyph_search",",","glyph_replace",",","line",")","# Linkify.","line","=","re",".","sub","(","re",".","compile","(","url",",","re",".","VERBOSE",")",",","r'''<a href=\"\\1\">\\1<\/a>'''",",","line",")","line","=","re",".","sub","(","re",".","compile","(","email",",","re",".","VERBOSE",")",",","r'''<a href=\"mailto:\\1\">\\1<\/a>'''",",","line",")","lines",".","append","(","line",")","text","=","''",".","join","(","lines",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2372-L2475"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.qtags","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Quick tags formatting.\n\n        This function does the inline formatting of text, like\n        bold, italic, strong and also itex code.\n\n        ---\n        h1. Quick tags\n\n        Quick tags allow you to format your text, making it bold, \n        emphasized or small, for example. The quick tags operators\n        include:\n\n        dl. ==*strong*==:Translates into @<strong>strong<\/strong>@.\n        ==_emphasis_==:Translates into @<em>emphasis<\/em>@. \n        ==**bold**==:Translates into @<b>bold<\/b>@. \n        ==__italics__==:Translates into @<i>italics<\/i>@. \n        ==++bigger++==:Translates into @<big>bigger<\/big>@. \n        ==--smaller--==:Translates into: @<small>smaller<\/small>@. \n        ==-deleted text-==:Translates into @<del>deleted text<\/del>@. \n        ==+inserted text+==:Translates into @<ins>inserted text<\/ins>@. \n        ==^superscript^==:Translates into @<sup>superscript<\/sup>@. \n        ==~subscript~==:Translates into @<sub>subscript<\/sub>@. \n        ==%span%==:Translates into @<span>span<\/span>@. \n        ==@code@==:Translates into @<code>code<\/code>@. \n        \n        Note that within a \"==@==...==@==\" section, @<@ and @>@ are\n        translated into HTML entities automatically. \n\n        Inline formatting operators accept the following modifiers:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule. \n        [ll]:A language identifier (for a \"lang\" attribute). \n        (class) or (#id) or (class#id):For CSS(Cascading Style Sheets) class and id attributes.","docstring_summary":"Quick tags formatting.","docstring_tokens":["Quick","tags","formatting","."],"function":"def qtags(self, text):\n        \"\"\"Quick tags formatting.\n\n        This function does the inline formatting of text, like\n        bold, italic, strong and also itex code.\n\n        ---\n        h1. Quick tags\n\n        Quick tags allow you to format your text, making it bold, \n        emphasized or small, for example. The quick tags operators\n        include:\n\n        dl. ==*strong*==:Translates into @<strong>strong<\/strong>@.\n        ==_emphasis_==:Translates into @<em>emphasis<\/em>@. \n        ==**bold**==:Translates into @<b>bold<\/b>@. \n        ==__italics__==:Translates into @<i>italics<\/i>@. \n        ==++bigger++==:Translates into @<big>bigger<\/big>@. \n        ==--smaller--==:Translates into: @<small>smaller<\/small>@. \n        ==-deleted text-==:Translates into @<del>deleted text<\/del>@. \n        ==+inserted text+==:Translates into @<ins>inserted text<\/ins>@. \n        ==^superscript^==:Translates into @<sup>superscript<\/sup>@. \n        ==~subscript~==:Translates into @<sub>subscript<\/sub>@. \n        ==%span%==:Translates into @<span>span<\/span>@. \n        ==@code@==:Translates into @<code>code<\/code>@. \n        \n        Note that within a \"==@==...==@==\" section, @<@ and @>@ are\n        translated into HTML entities automatically. \n\n        Inline formatting operators accept the following modifiers:\n\n        dl. {style rule}:A CSS(Cascading Style Sheets) style rule. \n        [ll]:A language identifier (for a \"lang\" attribute). \n        (class) or (#id) or (class#id):For CSS(Cascading Style Sheets) class and id attributes. \n        \"\"\"\n        # itex2mml.\n        text = re.sub('\\$(.*?)\\$', lambda m: self.itex(m.group()), text)\n\n        # Add span tags to upper-case words which don't have a description.\n        #text = preg_replace(r'''(^|\\s)([A-Z]{3,})\\b(?!\\()''', r'''\\1<span class=\"caps\">\\2<\/span>''', text)\n        \n        # Quick tags.\n        qtags = [('**', 'b',      {'qf': '(?<!\\*)\\*\\*(?!\\*)', 'cls': '\\*'}),\n                 ('__', 'i',      {'qf': '(?<!_)__(?!_)', 'cls': '_'}),\n                 ('??', 'cite',   {'qf': '\\?\\?(?!\\?)', 'cls': '\\?'}),\n                 ('-',  'del',    {'qf': '(?<!\\-)\\-(?!\\-)', 'cls': '-'}),\n                 ('+',  'ins',    {'qf': '(?<!\\+)\\+(?!\\+)', 'cls': '\\+'}),\n                 ('*',  'strong', {'qf': '(?<!\\*)\\*(?!\\*)', 'cls': '\\*'}),\n                 ('_',  'em',     {'qf': '(?<!_)_(?!_)', 'cls': '_'}),\n                 ('++', 'big',    {'qf': '(?<!\\+)\\+\\+(?!\\+)', 'cls': '\\+\\+'}),\n                 ('--', 'small',  {'qf': '(?<!\\-)\\-\\-(?!\\-)', 'cls': '\\-\\-'}),\n                 ('~',  'sub',    {'qf': '(?<!\\~)\\~(?!(\\\\\\\/~))', 'cls': '\\~'}),\n                 ('@',  'code',   {'qf': '(?<!@)@(?!@)', 'cls': '@'}),\n                 ('%',  'span',   {'qf': '(?<!%)%(?!%)', 'cls': '%'}),\n                ]\n\n        # Superscript.\n        text = re.sub(r'''(?<!\\^)\\^(?!\\^)(.+?)(?<!\\^)\\^(?!\\^)''', r'''<sup>\\1<\/sup>''', text)\n\n        # This is from the perl version of Textile.\n        for qtag, htmltag, redict in qtags:\n            self.res.update(redict)\n            p = re.compile(r'''(?:                          #\n                                   ^                        # Start of string\n                                   |                        #\n                                   (?<=[\\s>'\"])             # Whitespace, end of tag, quotes\n                                   |                        #\n                                   (?P<pre>[{[])            # Surrounded by [ or {\n                                   |                        #\n                                   (?<=%(punct)s)           # Punctuation\n                               )                            #\n                               %(qf)s                       # opening tag\n                               %(qattr)s                    # attributes\n                               (?P<text>[^%(cls)s\\s].*?)    # text\n                               (?<=\\S)                      # non-whitespace\n                               %(qf)s                       # \n                               (?:                          #\n                                   $                        # End of string\n                                   |                        #\n                                   (?P<post>[\\]}])          # Surrounded by ] or }\n                                   |                        # \n                                   (?=%(punct)s{1,2}|\\s)    # punctuation\n                                )                           #\n                             ''' % self.res, re.VERBOSE)\n\n            def _replace(m):\n                c = m.groupdict('')\n\n                attributes = self.parse_params(c['parameters'])\n                open_tag  = self.build_open_tag(htmltag, attributes) \n                close_tag = '<\/%s>' % htmltag\n\n                # Replace < and > inside <code><\/code>.\n                if htmltag == 'code':\n                    c['text'] = c['text'].replace('<', '&lt;')\n                    c['text'] = c['text'].replace('>', '&gt;')\n         \n                return open_tag + c['text'] + close_tag\n\n            text = p.sub(_replace, text)\n\n        return text","function_tokens":["def","qtags","(","self",",","text",")",":","# itex2mml.","text","=","re",".","sub","(","'\\$(.*?)\\$'",",","lambda","m",":","self",".","itex","(","m",".","group","(",")",")",",","text",")","# Add span tags to upper-case words which don't have a description.","#text = preg_replace(r'''(^|\\s)([A-Z]{3,})\\b(?!\\()''', r'''\\1<span class=\"caps\">\\2<\/span>''', text)","# Quick tags.","qtags","=","[","(","'**'",",","'b'",",","{","'qf'",":","'(?<!\\*)\\*\\*(?!\\*)'",",","'cls'",":","'\\*'","}",")",",","(","'__'",",","'i'",",","{","'qf'",":","'(?<!_)__(?!_)'",",","'cls'",":","'_'","}",")",",","(","'??'",",","'cite'",",","{","'qf'",":","'\\?\\?(?!\\?)'",",","'cls'",":","'\\?'","}",")",",","(","'-'",",","'del'",",","{","'qf'",":","'(?<!\\-)\\-(?!\\-)'",",","'cls'",":","'-'","}",")",",","(","'+'",",","'ins'",",","{","'qf'",":","'(?<!\\+)\\+(?!\\+)'",",","'cls'",":","'\\+'","}",")",",","(","'*'",",","'strong'",",","{","'qf'",":","'(?<!\\*)\\*(?!\\*)'",",","'cls'",":","'\\*'","}",")",",","(","'_'",",","'em'",",","{","'qf'",":","'(?<!_)_(?!_)'",",","'cls'",":","'_'","}",")",",","(","'++'",",","'big'",",","{","'qf'",":","'(?<!\\+)\\+\\+(?!\\+)'",",","'cls'",":","'\\+\\+'","}",")",",","(","'--'",",","'small'",",","{","'qf'",":","'(?<!\\-)\\-\\-(?!\\-)'",",","'cls'",":","'\\-\\-'","}",")",",","(","'~'",",","'sub'",",","{","'qf'",":","'(?<!\\~)\\~(?!(\\\\\\\/~))'",",","'cls'",":","'\\~'","}",")",",","(","'@'",",","'code'",",","{","'qf'",":","'(?<!@)@(?!@)'",",","'cls'",":","'@'","}",")",",","(","'%'",",","'span'",",","{","'qf'",":","'(?<!%)%(?!%)'",",","'cls'",":","'%'","}",")",",","]","# Superscript.","text","=","re",".","sub","(","r'''(?<!\\^)\\^(?!\\^)(.+?)(?<!\\^)\\^(?!\\^)'''",",","r'''<sup>\\1<\/sup>'''",",","text",")","# This is from the perl version of Textile.","for","qtag",",","htmltag",",","redict","in","qtags",":","self",".","res",".","update","(","redict",")","p","=","re",".","compile","(","r'''(?:                          #\n                                   ^                        # Start of string\n                                   |                        #\n                                   (?<=[\\s>'\"])             # Whitespace, end of tag, quotes\n                                   |                        #\n                                   (?P<pre>[{[])            # Surrounded by [ or {\n                                   |                        #\n                                   (?<=%(punct)s)           # Punctuation\n                               )                            #\n                               %(qf)s                       # opening tag\n                               %(qattr)s                    # attributes\n                               (?P<text>[^%(cls)s\\s].*?)    # text\n                               (?<=\\S)                      # non-whitespace\n                               %(qf)s                       # \n                               (?:                          #\n                                   $                        # End of string\n                                   |                        #\n                                   (?P<post>[\\]}])          # Surrounded by ] or }\n                                   |                        # \n                                   (?=%(punct)s{1,2}|\\s)    # punctuation\n                                )                           #\n                             '''","%","self",".","res",",","re",".","VERBOSE",")","def","_replace","(","m",")",":","c","=","m",".","groupdict","(","''",")","attributes","=","self",".","parse_params","(","c","[","'parameters'","]",")","open_tag","=","self",".","build_open_tag","(","htmltag",",","attributes",")","close_tag","=","'<\/%s>'","%","htmltag","# Replace < and > inside <code><\/code>.","if","htmltag","==","'code'",":","c","[","'text'","]","=","c","[","'text'","]",".","replace","(","'<'",",","'&lt;'",")","c","[","'text'","]","=","c","[","'text'","]",".","replace","(","'>'",",","'&gt;'",")","return","open_tag","+","c","[","'text'","]","+","close_tag","text","=","p",".","sub","(","_replace",",","text",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2478-L2579"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.images","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Process images.\n\n        This function process images tags, with or without links. Images\n        can have vertical and\/or horizontal alignment, and can be resized\n        unefficiently using width and height tags.\n\n        ---\n        h1. Images\n\n        An image is generated by enclosing the image source in @!@:\n\n        pre. !\/path\/to\/image!\n\n        You may optionally specify an alternative text for the image, which\n        will also be used as its title:\n\n        pre. !image.jpg (Nice picture)!\n\n        Becomes:\n\n        pre. <p><img src=\"image.jpg\" alt=\"Nice picture\" title=\"Nice picture\" \/><\/p>\n\n        If you want to make the image point to a link, simply append a\n        comma and the URL(Universal Republic of Love) to the image:\n\n        pre. !image.jpg!:http:\/\/diveintopython.org\n\n        Images can also be resized. These are all equivalent:\n\n        pre. !image.jpg 10x20!\n        !image.jpg 10w 20h!\n        !image.jpg 20h 10w!\n\n        The image @image.jpg@ will be resized to width 10 and height 20.\n\n        Modifiers to the @<img>@ tag go after the opening @!@:\n\n        pre. !(class#id)^image.jpg!\n\n        Allowed modifiers include:\n        \n        dl. &lt;:Align the image to the left (causes the image to float if CSS options are enabled). \n        &gt;:Align the image to the right (causes the image to float if CSS options are enabled). \n        - (dash):Aligns the image to the middle. \n        ^:Aligns the image to the top. \n        ~ (tilde):Aligns the image to the bottom. \n        {style rule}:Applies a CSS style rule to the image. \n        (class) or (#id) or (class#id):Applies a CSS class and\/or id to the image. \n        ( (one or more):Pads 1em on the left for each '(' character. \n        ) (one or more):Pads 1em on the right for each ')' character. \n\n        Images receive the class \"top\" when using top alignment, \"bottom\" \n        for bottom alignment and \"middle\" for middle alignment.","docstring_summary":"Process images.","docstring_tokens":["Process","images","."],"function":"def images(self, text):\n        \"\"\"Process images.\n\n        This function process images tags, with or without links. Images\n        can have vertical and\/or horizontal alignment, and can be resized\n        unefficiently using width and height tags.\n\n        ---\n        h1. Images\n\n        An image is generated by enclosing the image source in @!@:\n\n        pre. !\/path\/to\/image!\n\n        You may optionally specify an alternative text for the image, which\n        will also be used as its title:\n\n        pre. !image.jpg (Nice picture)!\n\n        Becomes:\n\n        pre. <p><img src=\"image.jpg\" alt=\"Nice picture\" title=\"Nice picture\" \/><\/p>\n\n        If you want to make the image point to a link, simply append a\n        comma and the URL(Universal Republic of Love) to the image:\n\n        pre. !image.jpg!:http:\/\/diveintopython.org\n\n        Images can also be resized. These are all equivalent:\n\n        pre. !image.jpg 10x20!\n        !image.jpg 10w 20h!\n        !image.jpg 20h 10w!\n\n        The image @image.jpg@ will be resized to width 10 and height 20.\n\n        Modifiers to the @<img>@ tag go after the opening @!@:\n\n        pre. !(class#id)^image.jpg!\n\n        Allowed modifiers include:\n        \n        dl. &lt;:Align the image to the left (causes the image to float if CSS options are enabled). \n        &gt;:Align the image to the right (causes the image to float if CSS options are enabled). \n        - (dash):Aligns the image to the middle. \n        ^:Aligns the image to the top. \n        ~ (tilde):Aligns the image to the bottom. \n        {style rule}:Applies a CSS style rule to the image. \n        (class) or (#id) or (class#id):Applies a CSS class and\/or id to the image. \n        ( (one or more):Pads 1em on the left for each '(' character. \n        ) (one or more):Pads 1em on the right for each ')' character. \n\n        Images receive the class \"top\" when using top alignment, \"bottom\" \n        for bottom alignment and \"middle\" for middle alignment.\n        \"\"\"\n        # Compile the beast.\n        p = re.compile(r'''\\!               # Opening !\n                           %(iattr)s        # Image attributes\n                           (?P<src>%(url)s) # Image src\n                           \\s?              # Optional whitesapce\n                           (                #\n                               \\(           #\n                               (?P<alt>.*?) # Optional (alt) attribute\n                               \\)           #\n                           )?               #\n                           \\s?              # Optional whitespace\n                           %(resize)s       # Resize parameters\n                           \\!               # Closing !\n                           (                # Optional link\n                               :            #    starts with ':'\n                               (?P<link>    #    \n                               %(url)s      #    link HREF\n                               )            #\n                           )?               #\n                        ''' % self.res, re.VERBOSE)\n\n        for m in p.finditer(text):\n            c = m.groupdict('')\n\n            # Build the parameters for the <img \/> tag.\n            attributes = self.parse_params(c['parameters'], align_type='image')\n            attributes.update(c)\n            if attributes['alt']:\n                attributes['title'] = attributes['alt']\n\n            # Append height and width.\n            attributes['width'] = m.groups()[5] or m.groups()[7] or m.groups()[10]\n            attributes['height'] = m.groups()[6] or m.groups()[8] or m.groups()[9]\n\n            # Create the image tag.\n            tag = self.image(attributes)\n\n            text = text.replace(m.group(), tag)\n        \n        return text","function_tokens":["def","images","(","self",",","text",")",":","# Compile the beast.","p","=","re",".","compile","(","r'''\\!               # Opening !\n                           %(iattr)s        # Image attributes\n                           (?P<src>%(url)s) # Image src\n                           \\s?              # Optional whitesapce\n                           (                #\n                               \\(           #\n                               (?P<alt>.*?) # Optional (alt) attribute\n                               \\)           #\n                           )?               #\n                           \\s?              # Optional whitespace\n                           %(resize)s       # Resize parameters\n                           \\!               # Closing !\n                           (                # Optional link\n                               :            #    starts with ':'\n                               (?P<link>    #    \n                               %(url)s      #    link HREF\n                               )            #\n                           )?               #\n                        '''","%","self",".","res",",","re",".","VERBOSE",")","for","m","in","p",".","finditer","(","text",")",":","c","=","m",".","groupdict","(","''",")","# Build the parameters for the <img \/> tag.","attributes","=","self",".","parse_params","(","c","[","'parameters'","]",",","align_type","=","'image'",")","attributes",".","update","(","c",")","if","attributes","[","'alt'","]",":","attributes","[","'title'","]","=","attributes","[","'alt'","]","# Append height and width.","attributes","[","'width'","]","=","m",".","groups","(",")","[","5","]","or","m",".","groups","(",")","[","7","]","or","m",".","groups","(",")","[","10","]","attributes","[","'height'","]","=","m",".","groups","(",")","[","6","]","or","m",".","groups","(",")","[","8","]","or","m",".","groups","(",")","[","9","]","# Create the image tag.","tag","=","self",".","image","(","attributes",")","text","=","text",".","replace","(","m",".","group","(",")",",","tag",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2582-L2676"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.image","parameters":"(self, attributes)","argument_list":"","return_statement":"return tag","docstring":"Process each image.\n\n        This method builds the <img> tag for each image in the text. It's\n        separated from the 'images' method so it can be easily overriden when\n        subclassing Textiler. Useful if you want to download and\/or process\n        the images, for example.","docstring_summary":"Process each image.","docstring_tokens":["Process","each","image","."],"function":"def image(self, attributes):\n        \"\"\"Process each image.\n\n        This method builds the <img> tag for each image in the text. It's\n        separated from the 'images' method so it can be easily overriden when\n        subclassing Textiler. Useful if you want to download and\/or process\n        the images, for example.\n        \"\"\"\n        link = attributes['link']\n        del attributes['link']\n        del attributes['parameters']\n\n        # Build the tag.\n        tag = self.build_open_tag('img', attributes, single=1)\n\n        if link:\n            href = preg_replace('&(?!(#|amp))', '&amp;', link)\n            tag = '<a href=\"%s\">%s<\/a>' % (href, tag)\n\n        return tag","function_tokens":["def","image","(","self",",","attributes",")",":","link","=","attributes","[","'link'","]","del","attributes","[","'link'","]","del","attributes","[","'parameters'","]","# Build the tag.","tag","=","self",".","build_open_tag","(","'img'",",","attributes",",","single","=","1",")","if","link",":","href","=","preg_replace","(","'&(?!(#|amp))'",",","'&amp;'",",","link",")","tag","=","'<a href=\"%s\">%s<\/a>'","%","(","href",",","tag",")","return","tag"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2679-L2698"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.links","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Process links.\n\n        This function is responsible for processing links. It has\n        some nice shortcuts to Google, Amazon and IMDB queries.\n\n        ---\n        h1. Links\n\n        A links is done the following way:\n\n        pre. \"This is the text link\":http:\/\/example.com\n\n        The result from this markup is:\n\n        pre. <p><a href=\"http:\/\/example.com\">This is the text link<\/a><\/p>\n\n        You can add an optional @title@ attribute:\n\n        pre. \"This is the text link(This is the title)\":http:\/\/example.com\n\n        The link can be customised as well:\n\n        pre. \"(nospam)E-mail me please\":mailto:someone@example.com\n\n        You can use either single or double quotes. They must be enclosed in\n        whitespace, punctuation or brackets:\n\n        pre. You[\"gotta\":http:\/\/example.com]seethis!\n\n        If you are going to reference the same link a couple of times, you\n        can define a lookup list anywhere on your document:\n\n        pre. [python]http:\/\/www.python.org\n\n        Links to the Python website can then be defined the following way:\n\n        pre. \"Check this\":python\n\n        There are also shortcuts for Amazon, IMDB(Internet Movie DataBase) and\n        Google queries:\n\n        pre. \"Has anyone seen this guy?\":imdb:Stephen+Fry\n        \"Really nice book\":amazon:Goedel+Escher+Bach\n        \"PyBlosxom\":google\n        [\"Using Textile and Blosxom with Python\":google:python blosxom textile]\n\n        Becomes:\n\n        pre. <a href=\"http:\/\/www.imdb.com\/Find?for=Stephen+Fry\">Has anyone seen this guy?<\/a>\n        <a href=\"http:\/\/www.amazon.com\/exec\/obidos\/external-search?index=blended&amp;keyword=Goedel+Escher+Bach\">Really nice book<\/a>\n        <a href=\"http:\/\/www.google.com\/search?q=PyBlosxom\">PyBlosxom<\/a>\n        <a href=\"http:\/\/www.google.com\/search?q=python+blosxom+textile\">Using Textile and Blosxom with Python<\/a>","docstring_summary":"Process links.","docstring_tokens":["Process","links","."],"function":"def links(self, text):\n        \"\"\"Process links.\n\n        This function is responsible for processing links. It has\n        some nice shortcuts to Google, Amazon and IMDB queries.\n\n        ---\n        h1. Links\n\n        A links is done the following way:\n\n        pre. \"This is the text link\":http:\/\/example.com\n\n        The result from this markup is:\n\n        pre. <p><a href=\"http:\/\/example.com\">This is the text link<\/a><\/p>\n\n        You can add an optional @title@ attribute:\n\n        pre. \"This is the text link(This is the title)\":http:\/\/example.com\n\n        The link can be customised as well:\n\n        pre. \"(nospam)E-mail me please\":mailto:someone@example.com\n\n        You can use either single or double quotes. They must be enclosed in\n        whitespace, punctuation or brackets:\n\n        pre. You[\"gotta\":http:\/\/example.com]seethis!\n\n        If you are going to reference the same link a couple of times, you\n        can define a lookup list anywhere on your document:\n\n        pre. [python]http:\/\/www.python.org\n\n        Links to the Python website can then be defined the following way:\n\n        pre. \"Check this\":python\n\n        There are also shortcuts for Amazon, IMDB(Internet Movie DataBase) and\n        Google queries:\n\n        pre. \"Has anyone seen this guy?\":imdb:Stephen+Fry\n        \"Really nice book\":amazon:Goedel+Escher+Bach\n        \"PyBlosxom\":google\n        [\"Using Textile and Blosxom with Python\":google:python blosxom textile]\n\n        Becomes:\n\n        pre. <a href=\"http:\/\/www.imdb.com\/Find?for=Stephen+Fry\">Has anyone seen this guy?<\/a>\n        <a href=\"http:\/\/www.amazon.com\/exec\/obidos\/external-search?index=blended&amp;keyword=Goedel+Escher+Bach\">Really nice book<\/a>\n        <a href=\"http:\/\/www.google.com\/search?q=PyBlosxom\">PyBlosxom<\/a>\n        <a href=\"http:\/\/www.google.com\/search?q=python+blosxom+textile\">Using Textile and Blosxom with Python<\/a>\n        \"\"\"\n        linkres = [r'''\\[                           # [\n                       (?P<quote>\"|')               # Opening quotes\n                       %(lattr)s                    # Link attributes\n                       (?P<text>[^\"]+?)             # Link text\n                       \\s?                          # Optional whitespace\n                       (?:\\((?P<title>[^\\)]+?)\\))?  # Optional (title)\n                       (?P=quote)                   # Closing quotes\n                       :                            # :\n                       (?P<href>[^\\]]+)             # HREF\n                       \\]                           # ]\n                    ''' % self.res,\n                   r'''(?P<quote>\"|')               # Opening quotes\n                       %(lattr)s                    # Link attributes\n                       (?P<text>[^\"]+?)             # Link text\n                       \\s?                          # Optional whitespace\n                       (?:\\((?P<title>[^\\)]+?)\\))?  # Optional (title)\n                       (?P=quote)                   # Closing quotes\n                       :                            # :\n                       (?P<href>%(url)s)            # HREF\n                    ''' % self.res]\n\n        for linkre in linkres:\n            p = re.compile(linkre, re.VERBOSE)\n            for m in p.finditer(text):\n                c = m.groupdict('')\n\n                attributes = self.parse_params(c['parameters'])\n                attributes['title'] = c['title'].replace('\"', '&quot;')\n\n                # Search lookup list.\n                link = self._links.get(c['href'], None) or c['href']\n\n                # Hyperlinks for Amazon, IMDB and Google searches.\n                parts = link.split(':', 1)\n                proto = parts[0]\n                if len(parts) == 2:\n                    query = parts[1]\n                else:\n                    query = c['text']\n\n                query = query.replace(' ', '+')\n\n                # Look for smart search.\n                if self.searches.has_key(proto):\n                    link = self.searches[proto] % query\n                \n                # Fix URL.\n                attributes['href'] = preg_replace('&(?!(#|amp))', '&amp;', link)\n\n                open_tag = self.build_open_tag('a', attributes)\n                close_tag = '<\/a>'\n\n                repl = open_tag + c['text'] + close_tag\n\n                text = text.replace(m.group(), repl)\n\n        return text","function_tokens":["def","links","(","self",",","text",")",":","linkres","=","[","r'''\\[                           # [\n                       (?P<quote>\"|')               # Opening quotes\n                       %(lattr)s                    # Link attributes\n                       (?P<text>[^\"]+?)             # Link text\n                       \\s?                          # Optional whitespace\n                       (?:\\((?P<title>[^\\)]+?)\\))?  # Optional (title)\n                       (?P=quote)                   # Closing quotes\n                       :                            # :\n                       (?P<href>[^\\]]+)             # HREF\n                       \\]                           # ]\n                    '''","%","self",".","res",",","r'''(?P<quote>\"|')               # Opening quotes\n                       %(lattr)s                    # Link attributes\n                       (?P<text>[^\"]+?)             # Link text\n                       \\s?                          # Optional whitespace\n                       (?:\\((?P<title>[^\\)]+?)\\))?  # Optional (title)\n                       (?P=quote)                   # Closing quotes\n                       :                            # :\n                       (?P<href>%(url)s)            # HREF\n                    '''","%","self",".","res","]","for","linkre","in","linkres",":","p","=","re",".","compile","(","linkre",",","re",".","VERBOSE",")","for","m","in","p",".","finditer","(","text",")",":","c","=","m",".","groupdict","(","''",")","attributes","=","self",".","parse_params","(","c","[","'parameters'","]",")","attributes","[","'title'","]","=","c","[","'title'","]",".","replace","(","'\"'",",","'&quot;'",")","# Search lookup list.","link","=","self",".","_links",".","get","(","c","[","'href'","]",",","None",")","or","c","[","'href'","]","# Hyperlinks for Amazon, IMDB and Google searches.","parts","=","link",".","split","(","':'",",","1",")","proto","=","parts","[","0","]","if","len","(","parts",")","==","2",":","query","=","parts","[","1","]","else",":","query","=","c","[","'text'","]","query","=","query",".","replace","(","' '",",","'+'",")","# Look for smart search.","if","self",".","searches",".","has_key","(","proto",")",":","link","=","self",".","searches","[","proto","]","%","query","# Fix URL.","attributes","[","'href'","]","=","preg_replace","(","'&(?!(#|amp))'",",","'&amp;'",",","link",")","open_tag","=","self",".","build_open_tag","(","'a'",",","attributes",")","close_tag","=","'<\/a>'","repl","=","open_tag","+","c","[","'text'","]","+","close_tag","text","=","text",".","replace","(","m",".","group","(",")",",","repl",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2701-L2811"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.format","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Text formatting.\n\n        This function basically defines the order on which the \n        formatting is applied.","docstring_summary":"Text formatting.","docstring_tokens":["Text","formatting","."],"function":"def format(self, text):\n        \"\"\"Text formatting.\n\n        This function basically defines the order on which the \n        formatting is applied.\n        \"\"\"\n        text = self.qtags(text)\n        text = self.images(text)\n        text = self.links(text)\n        text = self.acronym(text)\n        text = self.glyphs(text)\n\n        return text","function_tokens":["def","format","(","self",",","text",")",":","text","=","self",".","qtags","(","text",")","text","=","self",".","images","(","text",")","text","=","self",".","links","(","text",")","text","=","self",".","acronym","(","text",")","text","=","self",".","glyphs","(","text",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2814-L2826"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/textile.py","language":"python","identifier":"Textiler.inline","parameters":"(self, text)","argument_list":"","return_statement":"return text","docstring":"Inline formatting.\n\n        This function calls the formatting on the inline text,\n        taking care to avoid the escaped parts.\n\n        ---\n        h1. Inline \n\n        Inline formatting is applied within a block of text.","docstring_summary":"Inline formatting.","docstring_tokens":["Inline","formatting","."],"function":"def inline(self, text):\n        \"\"\"Inline formatting.\n\n        This function calls the formatting on the inline text,\n        taking care to avoid the escaped parts.\n\n        ---\n        h1. Inline \n\n        Inline formatting is applied within a block of text.\n        \"\"\"\n        if not re.search(r'''==(.*?)==''', text):\n            text = self.format(text)\n\n        else:\n            lines = []\n            # Else split the text into an array at <>.\n            for line in re.split('(==.*?==)', text):\n                if not re.match('==.*?==', line):\n                    line = self.format(line)\n                else:\n                    line = line[2:-2]\n\n                lines.append(line)\n            \n            text = ''.join(lines)\n\n        return text","function_tokens":["def","inline","(","self",",","text",")",":","if","not","re",".","search","(","r'''==(.*?)=='''",",","text",")",":","text","=","self",".","format","(","text",")","else",":","lines","=","[","]","# Else split the text into an array at <>.","for","line","in","re",".","split","(","'(==.*?==)'",",","text",")",":","if","not","re",".","match","(","'==.*?=='",",","line",")",":","line","=","self",".","format","(","line",")","else",":","line","=","line","[","2",":","-","2","]","lines",".","append","(","line",")","text","=","''",".","join","(","lines",")","return","text"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/textile.py#L2829-L2856"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"dump","parameters":"(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,\n        allow_nan=True, cls=None, indent=None, separators=None,\n        encoding='utf-8', default=None, **kw)","argument_list":"","return_statement":"","docstring":"Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n    ``.write()``-supporting file-like object).\n\n    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \n    will be skipped instead of raising a ``TypeError``.\n\n    If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``\n    may be ``unicode`` instances, subject to normal Python ``str`` to\n    ``unicode`` coercion rules. Unless ``fp.write()`` explicitly\n    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely\n    to cause an error.\n\n    If ``check_circular`` is ``False``, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)\n    in strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and object\n    members will be pretty-printed with that indent level. An indent level\n    of 0 will only insert newlines. ``None`` is the most compact representation.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg.","docstring_summary":"Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n    ``.write()``-supporting file-like object).","docstring_tokens":["Serialize","obj","as","a","JSON","formatted","stream","to","fp","(","a",".","write","()","-","supporting","file","-","like","object",")","."],"function":"def dump(obj, fp, skipkeys=False, ensure_ascii=True, check_circular=True,\n        allow_nan=True, cls=None, indent=None, separators=None,\n        encoding='utf-8', default=None, **kw):\n    \"\"\"\n    Serialize ``obj`` as a JSON formatted stream to ``fp`` (a\n    ``.write()``-supporting file-like object).\n\n    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \n    will be skipped instead of raising a ``TypeError``.\n\n    If ``ensure_ascii`` is ``False``, then the some chunks written to ``fp``\n    may be ``unicode`` instances, subject to normal Python ``str`` to\n    ``unicode`` coercion rules. Unless ``fp.write()`` explicitly\n    understands ``unicode`` (as in ``codecs.getwriter()``) this is likely\n    to cause an error.\n\n    If ``check_circular`` is ``False``, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``)\n    in strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and object\n    members will be pretty-printed with that indent level. An indent level\n    of 0 will only insert newlines. ``None`` is the most compact representation.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg.\n    \"\"\"\n    # cached encoder\n    if (skipkeys is False and ensure_ascii is True and\n        check_circular is True and allow_nan is True and\n        cls is None and indent is None and separators is None and\n        encoding == 'utf-8' and default is None and not kw):\n        iterable = _default_encoder.iterencode(obj)\n    else:\n        if cls is None:\n            cls = JSONEncoder\n        iterable = cls(skipkeys=skipkeys, ensure_ascii=ensure_ascii,\n            check_circular=check_circular, allow_nan=allow_nan, indent=indent,\n            separators=separators, encoding=encoding,\n            default=default, **kw).iterencode(obj)\n    # could accelerate with writelines in some versions of Python, at\n    # a debuggability cost\n    for chunk in iterable:\n        fp.write(chunk)","function_tokens":["def","dump","(","obj",",","fp",",","skipkeys","=","False",",","ensure_ascii","=","True",",","check_circular","=","True",",","allow_nan","=","True",",","cls","=","None",",","indent","=","None",",","separators","=","None",",","encoding","=","'utf-8'",",","default","=","None",",","*","*","kw",")",":","# cached encoder","if","(","skipkeys","is","False","and","ensure_ascii","is","True","and","check_circular","is","True","and","allow_nan","is","True","and","cls","is","None","and","indent","is","None","and","separators","is","None","and","encoding","==","'utf-8'","and","default","is","None","and","not","kw",")",":","iterable","=","_default_encoder",".","iterencode","(","obj",")","else",":","if","cls","is","None",":","cls","=","JSONEncoder","iterable","=","cls","(","skipkeys","=","skipkeys",",","ensure_ascii","=","ensure_ascii",",","check_circular","=","check_circular",",","allow_nan","=","allow_nan",",","indent","=","indent",",","separators","=","separators",",","encoding","=","encoding",",","default","=","default",",","*","*","kw",")",".","iterencode","(","obj",")","# could accelerate with writelines in some versions of Python, at","# a debuggability cost","for","chunk","in","iterable",":","fp",".","write","(","chunk",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L128-L187"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"dumps","parameters":"(obj, skipkeys=False, ensure_ascii=True, check_circular=True,\n        allow_nan=True, cls=None, indent=None, separators=None,\n        encoding='utf-8', default=None, **kw)","argument_list":"","return_statement":"return cls(\n        skipkeys=skipkeys, ensure_ascii=ensure_ascii,\n        check_circular=check_circular, allow_nan=allow_nan, indent=indent,\n        separators=separators, encoding=encoding, default=default,\n        **kw).encode(obj)","docstring":"Serialize ``obj`` to a JSON formatted ``str``.\n\n    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \n    will be skipped instead of raising a ``TypeError``.\n\n    If ``ensure_ascii`` is ``False``, then the return value will be a\n    ``unicode`` instance subject to normal Python ``str`` to ``unicode``\n    coercion rules instead of being escaped to an ASCII ``str``.\n\n    If ``check_circular`` is ``False``, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in\n    strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and\n    object members will be pretty-printed with that indent level. An indent\n    level of 0 will only insert newlines. ``None`` is the most compact\n    representation.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg.","docstring_summary":"Serialize ``obj`` to a JSON formatted ``str``.","docstring_tokens":["Serialize","obj","to","a","JSON","formatted","str","."],"function":"def dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True,\n        allow_nan=True, cls=None, indent=None, separators=None,\n        encoding='utf-8', default=None, **kw):\n    \"\"\"\n    Serialize ``obj`` to a JSON formatted ``str``.\n\n    If ``skipkeys`` is ``True`` then ``dict`` keys that are not basic types\n    (``str``, ``unicode``, ``int``, ``long``, ``float``, ``bool``, ``None``) \n    will be skipped instead of raising a ``TypeError``.\n\n    If ``ensure_ascii`` is ``False``, then the return value will be a\n    ``unicode`` instance subject to normal Python ``str`` to ``unicode``\n    coercion rules instead of being escaped to an ASCII ``str``.\n\n    If ``check_circular`` is ``False``, then the circular reference check\n    for container types will be skipped and a circular reference will\n    result in an ``OverflowError`` (or worse).\n\n    If ``allow_nan`` is ``False``, then it will be a ``ValueError`` to\n    serialize out of range ``float`` values (``nan``, ``inf``, ``-inf``) in\n    strict compliance of the JSON specification, instead of using the\n    JavaScript equivalents (``NaN``, ``Infinity``, ``-Infinity``).\n\n    If ``indent`` is a non-negative integer, then JSON array elements and\n    object members will be pretty-printed with that indent level. An indent\n    level of 0 will only insert newlines. ``None`` is the most compact\n    representation.\n\n    If ``separators`` is an ``(item_separator, dict_separator)`` tuple\n    then it will be used instead of the default ``(', ', ': ')`` separators.\n    ``(',', ':')`` is the most compact JSON representation.\n\n    ``encoding`` is the character encoding for str instances, default is UTF-8.\n\n    ``default(obj)`` is a function that should return a serializable version\n    of obj or raise TypeError. The default simply raises TypeError.\n\n    To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the\n    ``.default()`` method to serialize additional types), specify it with\n    the ``cls`` kwarg.\n    \"\"\"\n    # cached encoder\n    if (skipkeys is False and ensure_ascii is True and\n        check_circular is True and allow_nan is True and\n        cls is None and indent is None and separators is None and\n        encoding == 'utf-8' and default is None and not kw):\n        return _default_encoder.encode(obj)\n    if cls is None:\n        cls = JSONEncoder\n    return cls(\n        skipkeys=skipkeys, ensure_ascii=ensure_ascii,\n        check_circular=check_circular, allow_nan=allow_nan, indent=indent,\n        separators=separators, encoding=encoding, default=default,\n        **kw).encode(obj)","function_tokens":["def","dumps","(","obj",",","skipkeys","=","False",",","ensure_ascii","=","True",",","check_circular","=","True",",","allow_nan","=","True",",","cls","=","None",",","indent","=","None",",","separators","=","None",",","encoding","=","'utf-8'",",","default","=","None",",","*","*","kw",")",":","# cached encoder","if","(","skipkeys","is","False","and","ensure_ascii","is","True","and","check_circular","is","True","and","allow_nan","is","True","and","cls","is","None","and","indent","is","None","and","separators","is","None","and","encoding","==","'utf-8'","and","default","is","None","and","not","kw",")",":","return","_default_encoder",".","encode","(","obj",")","if","cls","is","None",":","cls","=","JSONEncoder","return","cls","(","skipkeys","=","skipkeys",",","ensure_ascii","=","ensure_ascii",",","check_circular","=","check_circular",",","allow_nan","=","allow_nan",",","indent","=","indent",",","separators","=","separators",",","encoding","=","encoding",",","default","=","default",",","*","*","kw",")",".","encode","(","obj",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L190-L243"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"load","parameters":"(fp, encoding=None, cls=None, object_hook=None, parse_float=None,\n        parse_int=None, parse_constant=None, **kw)","argument_list":"","return_statement":"return loads(fp.read(),\n        encoding=encoding, cls=cls, object_hook=object_hook,\n        parse_float=parse_float, parse_int=parse_int,\n        parse_constant=parse_constant, **kw)","docstring":"Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\n    a JSON document) to a Python object.\n\n    If the contents of ``fp`` is encoded with an ASCII based encoding other\n    than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must\n    be specified. Encodings that are not ASCII based (such as UCS-2) are\n    not allowed, and should be wrapped with\n    ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``\n    object and passed to ``loads()``\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n    \n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg.","docstring_summary":"Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\n    a JSON document) to a Python object.","docstring_tokens":["Deserialize","fp","(","a",".","read","()","-","supporting","file","-","like","object","containing","a","JSON","document",")","to","a","Python","object","."],"function":"def load(fp, encoding=None, cls=None, object_hook=None, parse_float=None,\n        parse_int=None, parse_constant=None, **kw):\n    \"\"\"\n    Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\n    a JSON document) to a Python object.\n\n    If the contents of ``fp`` is encoded with an ASCII based encoding other\n    than utf-8 (e.g. latin-1), then an appropriate ``encoding`` name must\n    be specified. Encodings that are not ASCII based (such as UCS-2) are\n    not allowed, and should be wrapped with\n    ``codecs.getreader(fp)(encoding)``, or simply decoded to a ``unicode``\n    object and passed to ``loads()``\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n    \n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg.\n    \"\"\"\n    return loads(fp.read(),\n        encoding=encoding, cls=cls, object_hook=object_hook,\n        parse_float=parse_float, parse_int=parse_int,\n        parse_constant=parse_constant, **kw)","function_tokens":["def","load","(","fp",",","encoding","=","None",",","cls","=","None",",","object_hook","=","None",",","parse_float","=","None",",","parse_int","=","None",",","parse_constant","=","None",",","*","*","kw",")",":","return","loads","(","fp",".","read","(",")",",","encoding","=","encoding",",","cls","=","cls",",","object_hook","=","object_hook",",","parse_float","=","parse_float",",","parse_int","=","parse_int",",","parse_constant","=","parse_constant",",","*","*","kw",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L249-L273"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"loads","parameters":"(s, encoding=None, cls=None, object_hook=None, parse_float=None,\n        parse_int=None, parse_constant=None, **kw)","argument_list":"","return_statement":"return cls(encoding=encoding, **kw).decode(s)","docstring":"Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON\n    document) to a Python object.\n\n    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding\n    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name\n    must be specified. Encodings that are not ASCII based (such as UCS-2)\n    are not allowed and should be decoded to ``unicode`` first.\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\n    ``parse_float``, if specified, will be called with the string\n    of every JSON float to be decoded. By default this is equivalent to\n    float(num_str). This can be used to use another datatype or parser\n    for JSON floats (e.g. decimal.Decimal).\n\n    ``parse_int``, if specified, will be called with the string\n    of every JSON int to be decoded. By default this is equivalent to\n    int(num_str). This can be used to use another datatype or parser\n    for JSON integers (e.g. float).\n\n    ``parse_constant``, if specified, will be called with one of the\n    following strings: -Infinity, Infinity, NaN, null, true, false.\n    This can be used to raise an exception if invalid JSON numbers\n    are encountered.\n\n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg.","docstring_summary":"Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON\n    document) to a Python object.","docstring_tokens":["Deserialize","s","(","a","str","or","unicode","instance","containing","a","JSON","document",")","to","a","Python","object","."],"function":"def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,\n        parse_int=None, parse_constant=None, **kw):\n    \"\"\"\n    Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON\n    document) to a Python object.\n\n    If ``s`` is a ``str`` instance and is encoded with an ASCII based encoding\n    other than utf-8 (e.g. latin-1) then an appropriate ``encoding`` name\n    must be specified. Encodings that are not ASCII based (such as UCS-2)\n    are not allowed and should be decoded to ``unicode`` first.\n\n    ``object_hook`` is an optional function that will be called with the\n    result of any object literal decode (a ``dict``). The return value of\n    ``object_hook`` will be used instead of the ``dict``. This feature\n    can be used to implement custom decoders (e.g. JSON-RPC class hinting).\n\n    ``parse_float``, if specified, will be called with the string\n    of every JSON float to be decoded. By default this is equivalent to\n    float(num_str). This can be used to use another datatype or parser\n    for JSON floats (e.g. decimal.Decimal).\n\n    ``parse_int``, if specified, will be called with the string\n    of every JSON int to be decoded. By default this is equivalent to\n    int(num_str). This can be used to use another datatype or parser\n    for JSON integers (e.g. float).\n\n    ``parse_constant``, if specified, will be called with one of the\n    following strings: -Infinity, Infinity, NaN, null, true, false.\n    This can be used to raise an exception if invalid JSON numbers\n    are encountered.\n\n    To use a custom ``JSONDecoder`` subclass, specify it with the ``cls``\n    kwarg.\n    \"\"\"\n    if (cls is None and encoding is None and object_hook is None and\n            parse_int is None and parse_float is None and\n            parse_constant is None and not kw):\n        return _default_decoder.decode(s)\n    if cls is None:\n        cls = JSONDecoder\n    if object_hook is not None:\n        kw['object_hook'] = object_hook\n    if parse_float is not None:\n        kw['parse_float'] = parse_float\n    if parse_int is not None:\n        kw['parse_int'] = parse_int\n    if parse_constant is not None:\n        kw['parse_constant'] = parse_constant\n    return cls(encoding=encoding, **kw).decode(s)","function_tokens":["def","loads","(","s",",","encoding","=","None",",","cls","=","None",",","object_hook","=","None",",","parse_float","=","None",",","parse_int","=","None",",","parse_constant","=","None",",","*","*","kw",")",":","if","(","cls","is","None","and","encoding","is","None","and","object_hook","is","None","and","parse_int","is","None","and","parse_float","is","None","and","parse_constant","is","None","and","not","kw",")",":","return","_default_decoder",".","decode","(","s",")","if","cls","is","None",":","cls","=","JSONDecoder","if","object_hook","is","not","None",":","kw","[","'object_hook'","]","=","object_hook","if","parse_float","is","not","None",":","kw","[","'parse_float'","]","=","parse_float","if","parse_int","is","not","None",":","kw","[","'parse_int'","]","=","parse_int","if","parse_constant","is","not","None",":","kw","[","'parse_constant'","]","=","parse_constant","return","cls","(","encoding","=","encoding",",","*","*","kw",")",".","decode","(","s",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L276-L324"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"decode","parameters":"(s)","argument_list":"","return_statement":"return loads(s)","docstring":"demjson, python-cjson API compatibility hook. Use loads(s) instead.","docstring_summary":"demjson, python-cjson API compatibility hook. Use loads(s) instead.","docstring_tokens":["demjson","python","-","cjson","API","compatibility","hook",".","Use","loads","(","s",")","instead","."],"function":"def decode(s):\n    \"\"\"\n    demjson, python-cjson API compatibility hook. Use loads(s) instead.\n    \"\"\"\n    import warnings\n    warnings.warn(\"simplejson.loads(s) should be used instead of decode(s)\",\n        DeprecationWarning)\n    return loads(s)","function_tokens":["def","decode","(","s",")",":","import","warnings","warnings",".","warn","(","\"simplejson.loads(s) should be used instead of decode(s)\"",",","DeprecationWarning",")","return","loads","(","s",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L332-L339"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"encode","parameters":"(obj)","argument_list":"","return_statement":"return dumps(obj)","docstring":"demjson, python-cjson compatibility hook. Use dumps(s) instead.","docstring_summary":"demjson, python-cjson compatibility hook. Use dumps(s) instead.","docstring_tokens":["demjson","python","-","cjson","compatibility","hook",".","Use","dumps","(","s",")","instead","."],"function":"def encode(obj):\n    \"\"\"\n    demjson, python-cjson compatibility hook. Use dumps(s) instead.\n    \"\"\"\n    import warnings\n    warnings.warn(\"simplejson.dumps(s) should be used instead of encode(s)\",\n        DeprecationWarning)\n    return dumps(obj)","function_tokens":["def","encode","(","obj",")",":","import","warnings","warnings",".","warn","(","\"simplejson.dumps(s) should be used instead of encode(s)\"",",","DeprecationWarning",")","return","dumps","(","obj",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L342-L349"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"read","parameters":"(s)","argument_list":"","return_statement":"return loads(s)","docstring":"jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use loads(s) instead.","docstring_summary":"jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use loads(s) instead.","docstring_tokens":["jsonlib","JsonUtils","python","-","json","json","-","py","API","compatibility","hook",".","Use","loads","(","s",")","instead","."],"function":"def read(s):\n    \"\"\"\n    jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use loads(s) instead.\n    \"\"\"\n    import warnings\n    warnings.warn(\"simplejson.loads(s) should be used instead of read(s)\",\n        DeprecationWarning)\n    return loads(s)","function_tokens":["def","read","(","s",")",":","import","warnings","warnings",".","warn","(","\"simplejson.loads(s) should be used instead of read(s)\"",",","DeprecationWarning",")","return","loads","(","s",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L352-L360"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/__init__.py","language":"python","identifier":"write","parameters":"(obj)","argument_list":"","return_statement":"return dumps(obj)","docstring":"jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use dumps(s) instead.","docstring_summary":"jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use dumps(s) instead.","docstring_tokens":["jsonlib","JsonUtils","python","-","json","json","-","py","API","compatibility","hook",".","Use","dumps","(","s",")","instead","."],"function":"def write(obj):\n    \"\"\"\n    jsonlib, JsonUtils, python-json, json-py API compatibility hook.\n    Use dumps(s) instead.\n    \"\"\"\n    import warnings\n    warnings.warn(\"simplejson.dumps(s) should be used instead of write(s)\",\n        DeprecationWarning)\n    return dumps(obj)","function_tokens":["def","write","(","obj",")",":","import","warnings","warnings",".","warn","(","\"simplejson.dumps(s) should be used instead of write(s)\"",",","DeprecationWarning",")","return","dumps","(","obj",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/__init__.py#L363-L371"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/scanner.py","language":"python","identifier":"Scanner.iterscan","parameters":"(self, string, idx=0, context=None)","argument_list":"","return_statement":"","docstring":"Yield match, end_idx for each match","docstring_summary":"Yield match, end_idx for each match","docstring_tokens":["Yield","match","end_idx","for","each","match"],"function":"def iterscan(self, string, idx=0, context=None):\n        \"\"\"\n        Yield match, end_idx for each match\n        \"\"\"\n        match = self.scanner.scanner(string, idx).match\n        actions = self.actions\n        lastend = idx\n        end = len(string)\n        while True:\n            m = match()\n            if m is None:\n                break\n            matchbegin, matchend = m.span()\n            if lastend == matchend:\n                break\n            action = actions[m.lastindex]\n            if action is not None:\n                rval, next_pos = action(m, context)\n                if next_pos is not None and next_pos != matchend:\n                    # \"fast forward\" the scanner\n                    matchend = next_pos\n                    match = self.scanner.scanner(string, matchend).match\n                yield rval, matchend\n            lastend = matchend","function_tokens":["def","iterscan","(","self",",","string",",","idx","=","0",",","context","=","None",")",":","match","=","self",".","scanner",".","scanner","(","string",",","idx",")",".","match","actions","=","self",".","actions","lastend","=","idx","end","=","len","(","string",")","while","True",":","m","=","match","(",")","if","m","is","None",":","break","matchbegin",",","matchend","=","m",".","span","(",")","if","lastend","==","matchend",":","break","action","=","actions","[","m",".","lastindex","]","if","action","is","not","None",":","rval",",","next_pos","=","action","(","m",",","context",")","if","next_pos","is","not","None","and","next_pos","!=","matchend",":","# \"fast forward\" the scanner","matchend","=","next_pos","match","=","self",".","scanner",".","scanner","(","string",",","matchend",")",".","match","yield","rval",",","matchend","lastend","=","matchend"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/scanner.py#L36-L59"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/decoder.py","language":"python","identifier":"JSONDecoder.__init__","parameters":"(self, encoding=None, object_hook=None, parse_float=None,\n            parse_int=None, parse_constant=None, strict=True)","argument_list":"","return_statement":"","docstring":"``encoding`` determines the encoding used to interpret any ``str``\n        objects decoded by this instance (utf-8 by default).  It has no\n        effect when decoding ``unicode`` objects.\n        \n        Note that currently only encodings that are a superset of ASCII work,\n        strings of other encodings should be passed in as ``unicode``.\n\n        ``object_hook``, if specified, will be called with the result\n        of every JSON object decoded and its return value will be used in\n        place of the given ``dict``.  This can be used to provide custom\n        deserializations (e.g. to support JSON-RPC class hinting).\n\n        ``parse_float``, if specified, will be called with the string\n        of every JSON float to be decoded. By default this is equivalent to\n        float(num_str). This can be used to use another datatype or parser\n        for JSON floats (e.g. decimal.Decimal).\n\n        ``parse_int``, if specified, will be called with the string\n        of every JSON int to be decoded. By default this is equivalent to\n        int(num_str). This can be used to use another datatype or parser\n        for JSON integers (e.g. float).\n\n        ``parse_constant``, if specified, will be called with one of the\n        following strings: -Infinity, Infinity, NaN, null, true, false.\n        This can be used to raise an exception if invalid JSON numbers\n        are encountered.","docstring_summary":"``encoding`` determines the encoding used to interpret any ``str``\n        objects decoded by this instance (utf-8 by default).  It has no\n        effect when decoding ``unicode`` objects.\n        \n        Note that currently only encodings that are a superset of ASCII work,\n        strings of other encodings should be passed in as ``unicode``.","docstring_tokens":["encoding","determines","the","encoding","used","to","interpret","any","str","objects","decoded","by","this","instance","(","utf","-","8","by","default",")",".","It","has","no","effect","when","decoding","unicode","objects",".","Note","that","currently","only","encodings","that","are","a","superset","of","ASCII","work","strings","of","other","encodings","should","be","passed","in","as","unicode","."],"function":"def __init__(self, encoding=None, object_hook=None, parse_float=None,\n            parse_int=None, parse_constant=None, strict=True):\n        \"\"\"\n        ``encoding`` determines the encoding used to interpret any ``str``\n        objects decoded by this instance (utf-8 by default).  It has no\n        effect when decoding ``unicode`` objects.\n        \n        Note that currently only encodings that are a superset of ASCII work,\n        strings of other encodings should be passed in as ``unicode``.\n\n        ``object_hook``, if specified, will be called with the result\n        of every JSON object decoded and its return value will be used in\n        place of the given ``dict``.  This can be used to provide custom\n        deserializations (e.g. to support JSON-RPC class hinting).\n\n        ``parse_float``, if specified, will be called with the string\n        of every JSON float to be decoded. By default this is equivalent to\n        float(num_str). This can be used to use another datatype or parser\n        for JSON floats (e.g. decimal.Decimal).\n\n        ``parse_int``, if specified, will be called with the string\n        of every JSON int to be decoded. By default this is equivalent to\n        int(num_str). This can be used to use another datatype or parser\n        for JSON integers (e.g. float).\n\n        ``parse_constant``, if specified, will be called with one of the\n        following strings: -Infinity, Infinity, NaN, null, true, false.\n        This can be used to raise an exception if invalid JSON numbers\n        are encountered.\n        \"\"\"\n        self.encoding = encoding\n        self.object_hook = object_hook\n        self.parse_float = parse_float\n        self.parse_int = parse_int\n        self.parse_constant = parse_constant\n        self.strict = strict","function_tokens":["def","__init__","(","self",",","encoding","=","None",",","object_hook","=","None",",","parse_float","=","None",",","parse_int","=","None",",","parse_constant","=","None",",","strict","=","True",")",":","self",".","encoding","=","encoding","self",".","object_hook","=","object_hook","self",".","parse_float","=","parse_float","self",".","parse_int","=","parse_int","self",".","parse_constant","=","parse_constant","self",".","strict","=","strict"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/decoder.py#L275-L310"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/decoder.py","language":"python","identifier":"JSONDecoder.decode","parameters":"(self, s, _w=WHITESPACE.match)","argument_list":"","return_statement":"return obj","docstring":"Return the Python representation of ``s`` (a ``str`` or ``unicode``\n        instance containing a JSON document)","docstring_summary":"Return the Python representation of ``s`` (a ``str`` or ``unicode``\n        instance containing a JSON document)","docstring_tokens":["Return","the","Python","representation","of","s","(","a","str","or","unicode","instance","containing","a","JSON","document",")"],"function":"def decode(self, s, _w=WHITESPACE.match):\n        \"\"\"\n        Return the Python representation of ``s`` (a ``str`` or ``unicode``\n        instance containing a JSON document)\n        \"\"\"\n        obj, end = self.raw_decode(s, idx=_w(s, 0).end())\n        end = _w(s, end).end()\n        if end != len(s):\n            raise ValueError(errmsg(\"Extra data\", s, end, len(s)))\n        return obj","function_tokens":["def","decode","(","self",",","s",",","_w","=","WHITESPACE",".","match",")",":","obj",",","end","=","self",".","raw_decode","(","s",",","idx","=","_w","(","s",",","0",")",".","end","(",")",")","end","=","_w","(","s",",","end",")",".","end","(",")","if","end","!=","len","(","s",")",":","raise","ValueError","(","errmsg","(","\"Extra data\"",",","s",",","end",",","len","(","s",")",")",")","return","obj"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/decoder.py#L312-L321"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/decoder.py","language":"python","identifier":"JSONDecoder.raw_decode","parameters":"(self, s, **kw)","argument_list":"","return_statement":"return obj, end","docstring":"Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning\n        with a JSON document) and return a 2-tuple of the Python\n        representation and the index in ``s`` where the document ended.\n\n        This can be used to decode a JSON document from a string that may\n        have extraneous data at the end.","docstring_summary":"Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning\n        with a JSON document) and return a 2-tuple of the Python\n        representation and the index in ``s`` where the document ended.","docstring_tokens":["Decode","a","JSON","document","from","s","(","a","str","or","unicode","beginning","with","a","JSON","document",")","and","return","a","2","-","tuple","of","the","Python","representation","and","the","index","in","s","where","the","document","ended","."],"function":"def raw_decode(self, s, **kw):\n        \"\"\"\n        Decode a JSON document from ``s`` (a ``str`` or ``unicode`` beginning\n        with a JSON document) and return a 2-tuple of the Python\n        representation and the index in ``s`` where the document ended.\n\n        This can be used to decode a JSON document from a string that may\n        have extraneous data at the end.\n        \"\"\"\n        kw.setdefault('context', self)\n        try:\n            obj, end = self._scanner.iterscan(s, **kw).next()\n        except StopIteration:\n            raise ValueError(\"No JSON object could be decoded\")\n        return obj, end","function_tokens":["def","raw_decode","(","self",",","s",",","*","*","kw",")",":","kw",".","setdefault","(","'context'",",","self",")","try",":","obj",",","end","=","self",".","_scanner",".","iterscan","(","s",",","*","*","kw",")",".","next","(",")","except","StopIteration",":","raise","ValueError","(","\"No JSON object could be decoded\"",")","return","obj",",","end"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/decoder.py#L323-L337"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/encoder.py","language":"python","identifier":"encode_basestring","parameters":"(s)","argument_list":"","return_statement":"return '\"' + ESCAPE.sub(replace, s) + '\"'","docstring":"Return a JSON representation of a Python string","docstring_summary":"Return a JSON representation of a Python string","docstring_tokens":["Return","a","JSON","representation","of","a","Python","string"],"function":"def encode_basestring(s):\n    \"\"\"\n    Return a JSON representation of a Python string\n    \"\"\"\n    def replace(match):\n        return ESCAPE_DCT[match.group(0)]\n    return '\"' + ESCAPE.sub(replace, s) + '\"'","function_tokens":["def","encode_basestring","(","s",")",":","def","replace","(","match",")",":","return","ESCAPE_DCT","[","match",".","group","(","0",")","]","return","'\"'","+","ESCAPE",".","sub","(","replace",",","s",")","+","'\"'"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/encoder.py#L45-L51"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/encoder.py","language":"python","identifier":"JSONEncoder.__init__","parameters":"(self, skipkeys=False, ensure_ascii=True,\n            check_circular=True, allow_nan=True, sort_keys=False,\n            indent=None, separators=None, encoding='utf-8', default=None)","argument_list":"","return_statement":"","docstring":"Constructor for JSONEncoder, with sensible defaults.\n\n        If skipkeys is False, then it is a TypeError to attempt\n        encoding of keys that are not str, int, long, float or None.  If\n        skipkeys is True, such items are simply skipped.\n\n        If ensure_ascii is True, the output is guaranteed to be str\n        objects with all incoming unicode characters escaped.  If\n        ensure_ascii is false, the output will be unicode object.\n\n        If check_circular is True, then lists, dicts, and custom encoded\n        objects will be checked for circular references during encoding to\n        prevent an infinite recursion (which would cause an OverflowError).\n        Otherwise, no such check takes place.\n\n        If allow_nan is True, then NaN, Infinity, and -Infinity will be\n        encoded as such.  This behavior is not JSON specification compliant,\n        but is consistent with most JavaScript based encoders and decoders.\n        Otherwise, it will be a ValueError to encode such floats.\n\n        If sort_keys is True, then the output of dictionaries will be\n        sorted by key; this is useful for regression tests to ensure\n        that JSON serializations can be compared on a day-to-day basis.\n\n        If indent is a non-negative integer, then JSON array\n        elements and object members will be pretty-printed with that\n        indent level.  An indent level of 0 will only insert newlines.\n        None is the most compact representation.\n\n        If specified, separators should be a (item_separator, key_separator)\n        tuple.  The default is (', ', ': ').  To get the most compact JSON\n        representation you should specify (',', ':') to eliminate whitespace.\n\n        If specified, default is a function that gets called for objects\n        that can't otherwise be serialized.  It should return a JSON encodable\n        version of the object or raise a ``TypeError``.\n\n        If encoding is not None, then all input strings will be\n        transformed into unicode using that encoding prior to JSON-encoding.\n        The default is UTF-8.","docstring_summary":"Constructor for JSONEncoder, with sensible defaults.","docstring_tokens":["Constructor","for","JSONEncoder","with","sensible","defaults","."],"function":"def __init__(self, skipkeys=False, ensure_ascii=True,\n            check_circular=True, allow_nan=True, sort_keys=False,\n            indent=None, separators=None, encoding='utf-8', default=None):\n        \"\"\"\n        Constructor for JSONEncoder, with sensible defaults.\n\n        If skipkeys is False, then it is a TypeError to attempt\n        encoding of keys that are not str, int, long, float or None.  If\n        skipkeys is True, such items are simply skipped.\n\n        If ensure_ascii is True, the output is guaranteed to be str\n        objects with all incoming unicode characters escaped.  If\n        ensure_ascii is false, the output will be unicode object.\n\n        If check_circular is True, then lists, dicts, and custom encoded\n        objects will be checked for circular references during encoding to\n        prevent an infinite recursion (which would cause an OverflowError).\n        Otherwise, no such check takes place.\n\n        If allow_nan is True, then NaN, Infinity, and -Infinity will be\n        encoded as such.  This behavior is not JSON specification compliant,\n        but is consistent with most JavaScript based encoders and decoders.\n        Otherwise, it will be a ValueError to encode such floats.\n\n        If sort_keys is True, then the output of dictionaries will be\n        sorted by key; this is useful for regression tests to ensure\n        that JSON serializations can be compared on a day-to-day basis.\n\n        If indent is a non-negative integer, then JSON array\n        elements and object members will be pretty-printed with that\n        indent level.  An indent level of 0 will only insert newlines.\n        None is the most compact representation.\n\n        If specified, separators should be a (item_separator, key_separator)\n        tuple.  The default is (', ', ': ').  To get the most compact JSON\n        representation you should specify (',', ':') to eliminate whitespace.\n\n        If specified, default is a function that gets called for objects\n        that can't otherwise be serialized.  It should return a JSON encodable\n        version of the object or raise a ``TypeError``.\n\n        If encoding is not None, then all input strings will be\n        transformed into unicode using that encoding prior to JSON-encoding.\n        The default is UTF-8.\n        \"\"\"\n\n        self.skipkeys = skipkeys\n        self.ensure_ascii = ensure_ascii\n        self.check_circular = check_circular\n        self.allow_nan = allow_nan\n        self.sort_keys = sort_keys\n        self.indent = indent\n        self.current_indent_level = 0\n        if separators is not None:\n            self.item_separator, self.key_separator = separators\n        if default is not None:\n            self.default = default\n        self.encoding = encoding","function_tokens":["def","__init__","(","self",",","skipkeys","=","False",",","ensure_ascii","=","True",",","check_circular","=","True",",","allow_nan","=","True",",","sort_keys","=","False",",","indent","=","None",",","separators","=","None",",","encoding","=","'utf-8'",",","default","=","None",")",":","self",".","skipkeys","=","skipkeys","self",".","ensure_ascii","=","ensure_ascii","self",".","check_circular","=","check_circular","self",".","allow_nan","=","allow_nan","self",".","sort_keys","=","sort_keys","self",".","indent","=","indent","self",".","current_indent_level","=","0","if","separators","is","not","None",":","self",".","item_separator",",","self",".","key_separator","=","separators","if","default","is","not","None",":","self",".","default","=","default","self",".","encoding","=","encoding"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/encoder.py#L112-L169"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/encoder.py","language":"python","identifier":"JSONEncoder.default","parameters":"(self, o)","argument_list":"","return_statement":"","docstring":"Implement this method in a subclass such that it returns\n        a serializable object for ``o``, or calls the base implementation\n        (to raise a ``TypeError``).\n\n        For example, to support arbitrary iterators, you could\n        implement default like this::\n            \n            def default(self, o):\n                try:\n                    iterable = iter(o)\n                except TypeError:\n                    pass\n                else:\n                    return list(iterable)\n                return JSONEncoder.default(self, o)","docstring_summary":"Implement this method in a subclass such that it returns\n        a serializable object for ``o``, or calls the base implementation\n        (to raise a ``TypeError``).","docstring_tokens":["Implement","this","method","in","a","subclass","such","that","it","returns","a","serializable","object","for","o","or","calls","the","base","implementation","(","to","raise","a","TypeError",")","."],"function":"def default(self, o):\n        \"\"\"\n        Implement this method in a subclass such that it returns\n        a serializable object for ``o``, or calls the base implementation\n        (to raise a ``TypeError``).\n\n        For example, to support arbitrary iterators, you could\n        implement default like this::\n            \n            def default(self, o):\n                try:\n                    iterable = iter(o)\n                except TypeError:\n                    pass\n                else:\n                    return list(iterable)\n                return JSONEncoder.default(self, o)\n        \"\"\"\n        raise TypeError(\"%r is not JSON serializable\" % (o,))","function_tokens":["def","default","(","self",",","o",")",":","raise","TypeError","(","\"%r is not JSON serializable\"","%","(","o",",",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/encoder.py#L320-L338"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/encoder.py","language":"python","identifier":"JSONEncoder.encode","parameters":"(self, o)","argument_list":"","return_statement":"return ''.join(chunks)","docstring":"Return a JSON string representation of a Python data structure.\n\n        >>> JSONEncoder().encode({\"foo\": [\"bar\", \"baz\"]})\n        '{\"foo\": [\"bar\", \"baz\"]}'","docstring_summary":"Return a JSON string representation of a Python data structure.","docstring_tokens":["Return","a","JSON","string","representation","of","a","Python","data","structure","."],"function":"def encode(self, o):\n        \"\"\"\n        Return a JSON string representation of a Python data structure.\n\n        >>> JSONEncoder().encode({\"foo\": [\"bar\", \"baz\"]})\n        '{\"foo\": [\"bar\", \"baz\"]}'\n        \"\"\"\n        # This is for extremely simple cases and benchmarks.\n        if isinstance(o, basestring):\n            if isinstance(o, str):\n                _encoding = self.encoding\n                if (_encoding is not None \n                        and not (_encoding == 'utf-8')):\n                    o = o.decode(_encoding)\n            if self.ensure_ascii:\n                return encode_basestring_ascii(o)\n            else:\n                return encode_basestring(o)\n        # This doesn't pass the iterator directly to ''.join() because the\n        # exceptions aren't as detailed.  The list call should be roughly\n        # equivalent to the PySequence_Fast that ''.join() would do.\n        chunks = list(self.iterencode(o))\n        return ''.join(chunks)","function_tokens":["def","encode","(","self",",","o",")",":","# This is for extremely simple cases and benchmarks.","if","isinstance","(","o",",","basestring",")",":","if","isinstance","(","o",",","str",")",":","_encoding","=","self",".","encoding","if","(","_encoding","is","not","None","and","not","(","_encoding","==","'utf-8'",")",")",":","o","=","o",".","decode","(","_encoding",")","if","self",".","ensure_ascii",":","return","encode_basestring_ascii","(","o",")","else",":","return","encode_basestring","(","o",")","# This doesn't pass the iterator directly to ''.join() because the","# exceptions aren't as detailed.  The list call should be roughly","# equivalent to the PySequence_Fast that ''.join() would do.","chunks","=","list","(","self",".","iterencode","(","o",")",")","return","''",".","join","(","chunks",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/encoder.py#L340-L362"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"utils\/external\/simplejson\/encoder.py","language":"python","identifier":"JSONEncoder.iterencode","parameters":"(self, o)","argument_list":"","return_statement":"return self._iterencode(o, markers)","docstring":"Encode the given object and yield each string\n        representation as available.\n        \n        For example::\n            \n            for chunk in JSONEncoder().iterencode(bigobject):\n                mysocket.write(chunk)","docstring_summary":"Encode the given object and yield each string\n        representation as available.\n        \n        For example::\n            \n            for chunk in JSONEncoder().iterencode(bigobject):\n                mysocket.write(chunk)","docstring_tokens":["Encode","the","given","object","and","yield","each","string","representation","as","available",".","For","example","::","for","chunk","in","JSONEncoder","()",".","iterencode","(","bigobject",")",":","mysocket",".","write","(","chunk",")"],"function":"def iterencode(self, o):\n        \"\"\"\n        Encode the given object and yield each string\n        representation as available.\n        \n        For example::\n            \n            for chunk in JSONEncoder().iterencode(bigobject):\n                mysocket.write(chunk)\n        \"\"\"\n        if self.check_circular:\n            markers = {}\n        else:\n            markers = None\n        return self._iterencode(o, markers)","function_tokens":["def","iterencode","(","self",",","o",")",":","if","self",".","check_circular",":","markers","=","{","}","else",":","markers","=","None","return","self",".","_iterencode","(","o",",","markers",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/utils\/external\/simplejson\/encoder.py#L364-L378"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"fix_thread_string","parameters":"(tstr)","argument_list":"","return_statement":"return '.'.join( map(three_digits, map(remove_slash, tstr.split('.'))))","docstring":"Takes a string with numbers separated by period and possibly with \/\n    at end, and outputs a string with 3 digit numbers separated by periods.","docstring_summary":"Takes a string with numbers separated by period and possibly with \/\n    at end, and outputs a string with 3 digit numbers separated by periods.","docstring_tokens":["Takes","a","string","with","numbers","separated","by","period","and","possibly","with","\/","at","end","and","outputs","a","string","with","3","digit","numbers","separated","by","periods","."],"function":"def fix_thread_string(tstr):\n    \"\"\"\n    Takes a string with numbers separated by period and possibly with \/\n    at end, and outputs a string with 3 digit numbers separated by periods.\n    \"\"\"\n    remove_slash = lambda s: s[:-1] if s[-1] == '\/' else s\n    three_digits = lambda s: \"%03d\" % int(s)\n    return '.'.join( map(three_digits, map(remove_slash, tstr.split('.'))))","function_tokens":["def","fix_thread_string","(","tstr",")",":","remove_slash","=","lambda","s",":","s","[",":","-","1","]","if","s","[","-","1","]","==","'\/'","else","s","three_digits","=","lambda","s",":","\"%03d\"","%","int","(","s",")","return","'.'",".","join","(","map","(","three_digits",",","map","(","remove_slash",",","tstr",".","split","(","'.'",")",")",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L141-L148"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"BlogConverter.get_articles","parameters":"(self)","argument_list":"","return_statement":"","docstring":"Returns an iterable of blog articles to be imported.","docstring_summary":"Returns an iterable of blog articles to be imported.","docstring_tokens":["Returns","an","iterable","of","blog","articles","to","be","imported","."],"function":"def get_articles(self):\n        \"\"\"Returns an iterable of blog articles to be imported.\"\"\"\n        raise NotImplementedError()","function_tokens":["def","get_articles","(","self",")",":","raise","NotImplementedError","(",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L278-L280"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"BlogConverter.get_article_tags","parameters":"(self, article)","argument_list":"","return_statement":"return article","docstring":"Annotates an article with tags.","docstring_summary":"Annotates an article with tags.","docstring_tokens":["Annotates","an","article","with","tags","."],"function":"def get_article_tags(self, article):\n        \"\"\"Annotates an article with tags.\"\"\"\n        return article","function_tokens":["def","get_article_tags","(","self",",","article",")",":","return","article"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L282-L284"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"BlogConverter.get_article_comments","parameters":"(self, article)","argument_list":"","return_statement":"return []","docstring":"Returns an iterable of comments associated with an article.","docstring_summary":"Returns an iterable of comments associated with an article.","docstring_tokens":["Returns","an","iterable","of","comments","associated","with","an","article","."],"function":"def get_article_comments(self, article):\n        \"\"\"Returns an iterable of comments associated with an article.\"\"\"\n        return []","function_tokens":["def","get_article_comments","(","self",",","article",")",":","return","[","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L286-L288"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"BlogConverter.get_redirects","parameters":"(self)","argument_list":"","return_statement":"return []","docstring":"Returns an iterable of (src, dest) redirect tuples.","docstring_summary":"Returns an iterable of (src, dest) redirect tuples.","docstring_tokens":["Returns","an","iterable","of","(","src","dest",")","redirect","tuples","."],"function":"def get_redirects(self):\n        \"\"\"Returns an iterable of (src, dest) redirect tuples.\"\"\"\n        return []","function_tokens":["def","get_redirects","(","self",")",":","return","[","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L290-L292"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"dev\/scripts\/uploader.py","language":"python","identifier":"DrupalConverter.get_html","parameters":"(self, raw_body, markup_type)","argument_list":"","return_statement":"return body","docstring":"Convert various Drupal formats to html","docstring_summary":"Convert various Drupal formats to html","docstring_tokens":["Convert","various","Drupal","formats","to","html"],"function":"def get_html(self, raw_body, markup_type):\n        \"\"\" Convert various Drupal formats to html \"\"\"\n        \n        utf8_body = fix_string(raw_body)\n\n        def repl(tmatch):\n            if tmatch:   # Assume latin-1.  Will be converted by Bloog.\n                return textile.textile(tmatch.group(1), \n                                       encoding='latin-1', output='latin-1')\n\n        # Because Drupal textile formatting allows use of [textile][\/textile] \n        # delimeters, remove them.\n        if markup_type == 'textile':\n            pattern = re.compile('\\[textile\\](.*)\\[\/textile\\]', \n                                 re.MULTILINE | re.IGNORECASE | re.DOTALL)\n            body = re.sub(pattern, repl, utf8_body)\n        elif markup_type == 'filtered html':\n            body = re.sub('\\n', '<br \/>', utf8_body)\n        else:\n            body = raw_body\n        return body","function_tokens":["def","get_html","(","self",",","raw_body",",","markup_type",")",":","utf8_body","=","fix_string","(","raw_body",")","def","repl","(","tmatch",")",":","if","tmatch",":","# Assume latin-1.  Will be converted by Bloog.","return","textile",".","textile","(","tmatch",".","group","(","1",")",",","encoding","=","'latin-1'",",","output","=","'latin-1'",")","# Because Drupal textile formatting allows use of [textile][\/textile] ","# delimeters, remove them.","if","markup_type","==","'textile'",":","pattern","=","re",".","compile","(","'\\[textile\\](.*)\\[\/textile\\]'",",","re",".","MULTILINE","|","re",".","IGNORECASE","|","re",".","DOTALL",")","body","=","re",".","sub","(","pattern",",","repl",",","utf8_body",")","elif","markup_type","==","'filtered html'",":","body","=","re",".","sub","(","'\\n'",",","'<br \/>'",",","utf8_body",")","else",":","body","=","raw_body","return","body"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/dev\/scripts\/uploader.py#L414-L434"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/__init__.py","language":"python","identifier":"to_dict","parameters":"(model_obj, attr_list, init_dict_func=None)","argument_list":"","return_statement":"return values","docstring":"Converts Model properties into various formats.\n\n    Supply a init_dict_func function that populates a\n    dictionary with values.  In the case of db.Model, this\n    would be something like _to_entity().  You may also\n    designate more complex properties in attr_list, like\n      \"counter.count\"\n    Each object in the chain will be retrieved.  In the\n    example above, the counter object will be retrieved\n    from model_obj's properties.  And then counter.count\n    will be retrieved.  The value returned will have a\n    key set to the last name in the chain, e.g. 'count' \n    in the above example.","docstring_summary":"Converts Model properties into various formats.","docstring_tokens":["Converts","Model","properties","into","various","formats","."],"function":"def to_dict(model_obj, attr_list, init_dict_func=None):\n    \"\"\"Converts Model properties into various formats.\n\n    Supply a init_dict_func function that populates a\n    dictionary with values.  In the case of db.Model, this\n    would be something like _to_entity().  You may also\n    designate more complex properties in attr_list, like\n      \"counter.count\"\n    Each object in the chain will be retrieved.  In the\n    example above, the counter object will be retrieved\n    from model_obj's properties.  And then counter.count\n    will be retrieved.  The value returned will have a\n    key set to the last name in the chain, e.g. 'count' \n    in the above example.\n    \"\"\"\n    values = {}\n    init_dict_func(values)\n    for token in attr_list:\n        elems = token.split('.')\n        value = getattr(model_obj, elems[0])\n        for elem in elems[1:]:\n            value = getattr(value, elem)\n        values[elems[-1]] = value\n    return values","function_tokens":["def","to_dict","(","model_obj",",","attr_list",",","init_dict_func","=","None",")",":","values","=","{","}","init_dict_func","(","values",")","for","token","in","attr_list",":","elems","=","token",".","split","(","'.'",")","value","=","getattr","(","model_obj",",","elems","[","0","]",")","for","elem","in","elems","[","1",":","]",":","value","=","getattr","(","value",",","elem",")","values","[","elems","[","-","1","]","]","=","value","return","values"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/__init__.py#L42-L65"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/__init__.py","language":"python","identifier":"replace_datastore_types","parameters":"(entity)","argument_list":"","return_statement":"","docstring":"Replaces any datastore types in a dictionary with standard types.\n    \n    Passed-in entities are assumed to be dictionaries with values that\n    can be at most a single list level.  These transformations are made:\n      datetime.datetime      -> string\n      db.Key                 -> key hash suitable for regenerating key\n      users.User             -> dict with 'nickname' and 'email'\n    TODO -- GeoPt when needed","docstring_summary":"Replaces any datastore types in a dictionary with standard types.\n    \n    Passed-in entities are assumed to be dictionaries with values that\n    can be at most a single list level.  These transformations are made:\n      datetime.datetime      -> string\n      db.Key                 -> key hash suitable for regenerating key\n      users.User             -> dict with 'nickname' and 'email'\n    TODO -- GeoPt when needed","docstring_tokens":["Replaces","any","datastore","types","in","a","dictionary","with","standard","types",".","Passed","-","in","entities","are","assumed","to","be","dictionaries","with","values","that","can","be","at","most","a","single","list","level",".","These","transformations","are","made",":","datetime",".","datetime","-",">","string","db",".","Key","-",">","key","hash","suitable","for","regenerating","key","users",".","User","-",">","dict","with","nickname","and","email","TODO","--","GeoPt","when","needed"],"function":"def replace_datastore_types(entity):\n    \"\"\"Replaces any datastore types in a dictionary with standard types.\n    \n    Passed-in entities are assumed to be dictionaries with values that\n    can be at most a single list level.  These transformations are made:\n      datetime.datetime      -> string\n      db.Key                 -> key hash suitable for regenerating key\n      users.User             -> dict with 'nickname' and 'email'\n    TODO -- GeoPt when needed\n    \"\"\"\n    def get_replacement(value):\n        if isinstance(value, datetime.datetime):\n            return value.strftime(\"%s %s\" % (DATE_FORMAT, TIME_FORMAT))\n        elif isinstance(value, datetime.date):\n            return value.strftime(DATE_FORMAT)\n        elif isinstance(value, datetime.time):\n            return value.strftime(TIME_FORMAT)\n        elif isinstance(value, datastore_types.Key):\n            return str(value)\n        elif isinstance(value, users.User):\n            return { 'nickname': value.nickname(), \n                     'email': value.email() }\n        else:\n            return None\n\n    for key, value in entity.iteritems():\n        if isinstance(value, list):\n            new_list = []\n            for item in value:\n                new_value = get_replacement(item)\n                new_list.append(new_value or item)\n            entity[key] = new_list\n        else:\n            new_value = get_replacement(value)\n            if new_value:\n                entity[key] = new_value","function_tokens":["def","replace_datastore_types","(","entity",")",":","def","get_replacement","(","value",")",":","if","isinstance","(","value",",","datetime",".","datetime",")",":","return","value",".","strftime","(","\"%s %s\"","%","(","DATE_FORMAT",",","TIME_FORMAT",")",")","elif","isinstance","(","value",",","datetime",".","date",")",":","return","value",".","strftime","(","DATE_FORMAT",")","elif","isinstance","(","value",",","datetime",".","time",")",":","return","value",".","strftime","(","TIME_FORMAT",")","elif","isinstance","(","value",",","datastore_types",".","Key",")",":","return","str","(","value",")","elif","isinstance","(","value",",","users",".","User",")",":","return","{","'nickname'",":","value",".","nickname","(",")",",","'email'",":","value",".","email","(",")","}","else",":","return","None","for","key",",","value","in","entity",".","iteritems","(",")",":","if","isinstance","(","value",",","list",")",":","new_list","=","[","]","for","item","in","value",":","new_value","=","get_replacement","(","item",")","new_list",".","append","(","new_value","or","item",")","entity","[","key","]","=","new_list","else",":","new_value","=","get_replacement","(","value",")","if","new_value",":","entity","[","key","]","=","new_value"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/__init__.py#L71-L106"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/__init__.py","language":"python","identifier":"MemcachedModel.list","parameters":"(cls, nocache=False)","argument_list":"","return_statement":"return eval(list_repr)","docstring":"Returns a list of up to 1000 dicts of model values.\n           Unless nocache is set to True, memcache will be checked first.\n        Returns:\n          List of dicts with each dict holding an entities property names\n          and values.","docstring_summary":"Returns a list of up to 1000 dicts of model values.\n           Unless nocache is set to True, memcache will be checked first.\n        Returns:\n          List of dicts with each dict holding an entities property names\n          and values.","docstring_tokens":["Returns","a","list","of","up","to","1000","dicts","of","model","values",".","Unless","nocache","is","set","to","True","memcache","will","be","checked","first",".","Returns",":","List","of","dicts","with","each","dict","holding","an","entities","property","names","and","values","."],"function":"def list(cls, nocache=False):\n        \"\"\"Returns a list of up to 1000 dicts of model values.\n           Unless nocache is set to True, memcache will be checked first.\n        Returns:\n          List of dicts with each dict holding an entities property names\n          and values.\n        \"\"\"\n        list_repr = memcache.get(cls.memcache_key())\n        if nocache or list_repr is None:\n            q = db.Query(cls)\n            objs = q.fetch(limit=1000)\n            list_repr = '[' + ','.join([obj._to_repr() for obj in objs]) + ']'\n            memcache.set(cls.memcache_key(), list_repr)\n        return eval(list_repr)","function_tokens":["def","list","(","cls",",","nocache","=","False",")",":","list_repr","=","memcache",".","get","(","cls",".","memcache_key","(",")",")","if","nocache","or","list_repr","is","None",":","q","=","db",".","Query","(","cls",")","objs","=","q",".","fetch","(","limit","=","1000",")","list_repr","=","'['","+","','",".","join","(","[","obj",".","_to_repr","(",")","for","obj","in","objs","]",")","+","']'","memcache",".","set","(","cls",".","memcache_key","(",")",",","list_repr",")","return","eval","(","list_repr",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/__init__.py#L170-L183"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableEntity.__init__","parameters":"(self, kind_or_entity, *args, **kwargs)","argument_list":"","return_statement":"","docstring":"Constructor. May be called as a copy constructor.\n\n    If kind_or_entity is a datastore.Entity, copies it into this Entity.\n    datastore.Get() and Query() returns instances of datastore.Entity, so this\n    is useful for converting them back to SearchableEntity so that they'll be\n    indexed when they're stored back in the datastore.\n\n    Otherwise, passes through the positional and keyword args to the\n    datastore.Entity constructor.\n\n    Args:\n      kind_or_entity: string or datastore.Entity","docstring_summary":"Constructor. May be called as a copy constructor.","docstring_tokens":["Constructor",".","May","be","called","as","a","copy","constructor","."],"function":"def __init__(self, kind_or_entity, *args, **kwargs):\n    \"\"\"Constructor. May be called as a copy constructor.\n\n    If kind_or_entity is a datastore.Entity, copies it into this Entity.\n    datastore.Get() and Query() returns instances of datastore.Entity, so this\n    is useful for converting them back to SearchableEntity so that they'll be\n    indexed when they're stored back in the datastore.\n\n    Otherwise, passes through the positional and keyword args to the\n    datastore.Entity constructor.\n\n    Args:\n      kind_or_entity: string or datastore.Entity\n    \"\"\"\n    if isinstance(kind_or_entity, datastore.Entity):\n      self._Entity__key = kind_or_entity._Entity__key\n      self.update(kind_or_entity)\n    else:\n      super(SearchableEntity, self).__init__(kind_or_entity, *args, **kwargs)","function_tokens":["def","__init__","(","self",",","kind_or_entity",",","*","args",",","*","*","kwargs",")",":","if","isinstance","(","kind_or_entity",",","datastore",".","Entity",")",":","self",".","_Entity__key","=","kind_or_entity",".","_Entity__key","self",".","update","(","kind_or_entity",")","else",":","super","(","SearchableEntity",",","self",")",".","__init__","(","kind_or_entity",",","*","args",",","*","*","kwargs",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L140-L158"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableEntity._ToPb","parameters":"(self)","argument_list":"","return_statement":"return super(SearchableEntity, self)._ToPb()","docstring":"Rebuilds the full text index, then delegates to the superclass.\n\n    Returns:\n      entity_pb.Entity","docstring_summary":"Rebuilds the full text index, then delegates to the superclass.","docstring_tokens":["Rebuilds","the","full","text","index","then","delegates","to","the","superclass","."],"function":"def _ToPb(self):\n    \"\"\"Rebuilds the full text index, then delegates to the superclass.\n\n    Returns:\n      entity_pb.Entity\n    \"\"\"\n    if SearchableEntity._FULL_TEXT_INDEX_PROPERTY in self:\n      del self[SearchableEntity._FULL_TEXT_INDEX_PROPERTY]\n\n    index = set()\n    searchable = lambda (name, value): name not in self.unsearchable_properties\n    for (name, values) in filter(searchable, self.items()):\n      if not isinstance(values, list):\n        values = [values]\n      if (isinstance(values[0], basestring) and\n          not isinstance(values[0], datastore_types.Blob)):\n        for value in values:\n          index.update(SearchableEntity._FullTextIndex(value))\n\n    index_list = list(index)\n    if index_list:\n      self[SearchableEntity._FULL_TEXT_INDEX_PROPERTY] = index_list\n\n    return super(SearchableEntity, self)._ToPb()","function_tokens":["def","_ToPb","(","self",")",":","if","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY","in","self",":","del","self","[","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY","]","index","=","set","(",")","searchable","=","lambda","(","name",",","value",")",":","name","not","in","self",".","unsearchable_properties","for","(","name",",","values",")","in","filter","(","searchable",",","self",".","items","(",")",")",":","if","not","isinstance","(","values",",","list",")",":","values","=","[","values","]","if","(","isinstance","(","values","[","0","]",",","basestring",")","and","not","isinstance","(","values","[","0","]",",","datastore_types",".","Blob",")",")",":","for","value","in","values",":","index",".","update","(","SearchableEntity",".","_FullTextIndex","(","value",")",")","index_list","=","list","(","index",")","if","index_list",":","self","[","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY","]","=","index_list","return","super","(","SearchableEntity",",","self",")",".","_ToPb","(",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L160-L183"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableEntity._FullTextIndex","parameters":"(cls, text)","argument_list":"","return_statement":"return words","docstring":"Returns a set of keywords appropriate for full text indexing.\n\n    See SearchableQuery.Search() for details.\n\n    Args:\n      text: string\n\n    Returns:\n      set of strings","docstring_summary":"Returns a set of keywords appropriate for full text indexing.","docstring_tokens":["Returns","a","set","of","keywords","appropriate","for","full","text","indexing","."],"function":"def _FullTextIndex(cls, text):\n    \"\"\"Returns a set of keywords appropriate for full text indexing.\n\n    See SearchableQuery.Search() for details.\n\n    Args:\n      text: string\n\n    Returns:\n      set of strings\n    \"\"\"\n\n    if text:\n      datastore_types.ValidateString(text, 'text', max_len=sys.maxint)\n      # TODO -- Remove embedded code blogs marked by 'pre' tags\n      # and name=\"code\"\n      text = cls._PUNCTUATION_REGEX.sub(' ', text)\n      words = text.lower().split()\n\n      words = set(words)\n\n      words -= cls._FULL_TEXT_STOP_WORDS\n      for word in list(words):\n        if len(word) < cls._FULL_TEXT_MIN_LENGTH:\n          words.remove(word)\n\n    else:\n      words = set()\n\n    return words","function_tokens":["def","_FullTextIndex","(","cls",",","text",")",":","if","text",":","datastore_types",".","ValidateString","(","text",",","'text'",",","max_len","=","sys",".","maxint",")","# TODO -- Remove embedded code blogs marked by 'pre' tags","# and name=\"code\"","text","=","cls",".","_PUNCTUATION_REGEX",".","sub","(","' '",",","text",")","words","=","text",".","lower","(",")",".","split","(",")","words","=","set","(","words",")","words","-=","cls",".","_FULL_TEXT_STOP_WORDS","for","word","in","list","(","words",")",":","if","len","(","word",")","<","cls",".","_FULL_TEXT_MIN_LENGTH",":","words",".","remove","(","word",")","else",":","words","=","set","(",")","return","words"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L186-L215"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableQuery.Search","parameters":"(self, search_query)","argument_list":"","return_statement":"return self","docstring":"Add a search query. This may be combined with filters.\n\n    Note that keywords in the search query will be silently dropped if they\n    are stop words or too short, ie if they wouldn't be indexed.\n\n    Args:\n     search_query: string\n\n    Returns:\n      # this query\n      SearchableQuery","docstring_summary":"Add a search query. This may be combined with filters.","docstring_tokens":["Add","a","search","query",".","This","may","be","combined","with","filters","."],"function":"def Search(self, search_query):\n    \"\"\"Add a search query. This may be combined with filters.\n\n    Note that keywords in the search query will be silently dropped if they\n    are stop words or too short, ie if they wouldn't be indexed.\n\n    Args:\n     search_query: string\n\n    Returns:\n      # this query\n      SearchableQuery\n    \"\"\"\n    datastore_types.ValidateString(search_query, 'search query')\n    self._search_query = search_query\n    return self","function_tokens":["def","Search","(","self",",","search_query",")",":","datastore_types",".","ValidateString","(","search_query",",","'search query'",")","self",".","_search_query","=","search_query","return","self"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L225-L240"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableQuery._ToPb","parameters":"(self, limit=None, offset=None)","argument_list":"","return_statement":"return pb","docstring":"Adds filters for the search query, then delegates to the superclass.\n\n    Raises BadFilterError if a filter on the index property already exists.\n\n    Args:\n      # an upper bound on the number of results returned by the query.\n      limit: int\n      # number of results that match the query to skip.  limit is applied\n      # after the offset is fulfilled.\n      offset: int\n\n    Returns:\n      datastore_pb.Query","docstring_summary":"Adds filters for the search query, then delegates to the superclass.","docstring_tokens":["Adds","filters","for","the","search","query","then","delegates","to","the","superclass","."],"function":"def _ToPb(self, limit=None, offset=None):\n    \"\"\"Adds filters for the search query, then delegates to the superclass.\n\n    Raises BadFilterError if a filter on the index property already exists.\n\n    Args:\n      # an upper bound on the number of results returned by the query.\n      limit: int\n      # number of results that match the query to skip.  limit is applied\n      # after the offset is fulfilled.\n      offset: int\n\n    Returns:\n      datastore_pb.Query\n    \"\"\"\n    if SearchableEntity._FULL_TEXT_INDEX_PROPERTY in self:\n      raise datastore_errors.BadFilterError(\n        '%s is a reserved name.' % SearchableEntity._FULL_TEXT_INDEX_PROPERTY)\n\n    pb = super(SearchableQuery, self)._ToPb(limit=limit, offset=offset)\n\n    if hasattr(self, '_search_query'):\n      keywords = SearchableEntity._FullTextIndex(self._search_query)\n      for keyword in keywords:\n        filter = pb.add_filter()\n        filter.set_op(datastore_pb.Query_Filter.EQUAL)\n        prop = filter.add_property()\n        prop.set_name(SearchableEntity._FULL_TEXT_INDEX_PROPERTY)\n        prop.mutable_value().set_stringvalue(keyword)\n\n    return pb","function_tokens":["def","_ToPb","(","self",",","limit","=","None",",","offset","=","None",")",":","if","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY","in","self",":","raise","datastore_errors",".","BadFilterError","(","'%s is a reserved name.'","%","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY",")","pb","=","super","(","SearchableQuery",",","self",")",".","_ToPb","(","limit","=","limit",",","offset","=","offset",")","if","hasattr","(","self",",","'_search_query'",")",":","keywords","=","SearchableEntity",".","_FullTextIndex","(","self",".","_search_query",")","for","keyword","in","keywords",":","filter","=","pb",".","add_filter","(",")","filter",".","set_op","(","datastore_pb",".","Query_Filter",".","EQUAL",")","prop","=","filter",".","add_property","(",")","prop",".","set_name","(","SearchableEntity",".","_FULL_TEXT_INDEX_PROPERTY",")","prop",".","mutable_value","(",")",".","set_stringvalue","(","keyword",")","return","pb"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L242-L272"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"FullTextQuery.search","parameters":"(self, search_query)","argument_list":"","return_statement":"return self","docstring":"Adds a full text search to this query.\n\n    Args:\n      search_query, a string containing the full text search query.\n\n    Returns:\n      self","docstring_summary":"Adds a full text search to this query.","docstring_tokens":["Adds","a","full","text","search","to","this","query","."],"function":"def search(self, search_query):\n    \"\"\"Adds a full text search to this query.\n\n    Args:\n      search_query, a string containing the full text search query.\n\n    Returns:\n      self\n    \"\"\"\n    self._search_query = search_query\n    return self","function_tokens":["def","search","(","self",",","search_query",")",":","self",".","_search_query","=","search_query","return","self"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L278-L288"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"FullTextQuery._get_query","parameters":"(self)","argument_list":"","return_statement":"return query","docstring":"Wraps db.Query._get_query() and injects SearchableQuery.","docstring_summary":"Wraps db.Query._get_query() and injects SearchableQuery.","docstring_tokens":["Wraps","db",".","Query",".","_get_query","()","and","injects","SearchableQuery","."],"function":"def _get_query(self):\n    \"\"\"Wraps db.Query._get_query() and injects SearchableQuery.\"\"\"\n    query = db.Query._get_query(self, _query_class=SearchableQuery)\n    if self._search_query:\n      query.Search(self._search_query)\n    return query","function_tokens":["def","_get_query","(","self",")",":","query","=","db",".","Query",".","_get_query","(","self",",","_query_class","=","SearchableQuery",")","if","self",".","_search_query",":","query",".","Search","(","self",".","_search_query",")","return","query"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L290-L295"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableModel._populate_internal_entity","parameters":"(self)","argument_list":"","return_statement":"return entity","docstring":"Wraps db.Model._populate_internal_entity() and injects\n    SearchableEntity.","docstring_summary":"Wraps db.Model._populate_internal_entity() and injects\n    SearchableEntity.","docstring_tokens":["Wraps","db",".","Model",".","_populate_internal_entity","()","and","injects","SearchableEntity","."],"function":"def _populate_internal_entity(self):\n    \"\"\"Wraps db.Model._populate_internal_entity() and injects\n    SearchableEntity.\"\"\"\n    entity = db.Model._populate_internal_entity(self,\n                                            _entity_class=SearchableEntity)\n    entity.unsearchable_properties = self.__class__.unsearchable_properties\n    return entity","function_tokens":["def","_populate_internal_entity","(","self",")",":","entity","=","db",".","Model",".","_populate_internal_entity","(","self",",","_entity_class","=","SearchableEntity",")","entity",".","unsearchable_properties","=","self",".","__class__",".","unsearchable_properties","return","entity"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L311-L317"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableModel.from_entity","parameters":"(cls, entity)","argument_list":"","return_statement":"return super(SearchableModel, cls).from_entity(entity)","docstring":"Wraps db.Model.from_entity() and injects SearchableEntity.","docstring_summary":"Wraps db.Model.from_entity() and injects SearchableEntity.","docstring_tokens":["Wraps","db",".","Model",".","from_entity","()","and","injects","SearchableEntity","."],"function":"def from_entity(cls, entity):\n    \"\"\"Wraps db.Model.from_entity() and injects SearchableEntity.\"\"\"\n    if not isinstance(entity, SearchableEntity):\n      entity = SearchableEntity(entity)\n    return super(SearchableModel, cls).from_entity(entity)","function_tokens":["def","from_entity","(","cls",",","entity",")",":","if","not","isinstance","(","entity",",","SearchableEntity",")",":","entity","=","SearchableEntity","(","entity",")","return","super","(","SearchableModel",",","cls",")",".","from_entity","(","entity",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L320-L324"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/search.py","language":"python","identifier":"SearchableModel.all","parameters":"(cls)","argument_list":"","return_statement":"return FullTextQuery(cls)","docstring":"Returns a FullTextQuery for this kind.","docstring_summary":"Returns a FullTextQuery for this kind.","docstring_tokens":["Returns","a","FullTextQuery","for","this","kind","."],"function":"def all(cls):\n    \"\"\"Returns a FullTextQuery for this kind.\"\"\"\n    return FullTextQuery(cls)","function_tokens":["def","all","(","cls",")",":","return","FullTextQuery","(","cls",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/search.py#L327-L329"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/blog.py","language":"python","identifier":"Article.get_comments","parameters":"(self)","argument_list":"","return_statement":"return [comment for comment in q]","docstring":"Return comments lexicographically sorted on thread string","docstring_summary":"Return comments lexicographically sorted on thread string","docstring_tokens":["Return","comments","lexicographically","sorted","on","thread","string"],"function":"def get_comments(self):\n        \"\"\"Return comments lexicographically sorted on thread string\"\"\"\n        q = db.GqlQuery(\"SELECT * FROM Comment \" +\n                        \"WHERE article = :1 \" +\n                        \"ORDER BY thread ASC\", self.key())\n        return [comment for comment in q]","function_tokens":["def","get_comments","(","self",")",":","q","=","db",".","GqlQuery","(","\"SELECT * FROM Comment \"","+","\"WHERE article = :1 \"","+","\"ORDER BY thread ASC\"",",","self",".","key","(",")",")","return","[","comment","for","comment","in","q","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/blog.py#L81-L86"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/blog.py","language":"python","identifier":"Article.set_associated_data","parameters":"(self, data)","argument_list":"","return_statement":"","docstring":"Serialize data that we'd like to store with this article.\n        Examples include relevant (per article) links and associated \n        Amazon items.","docstring_summary":"Serialize data that we'd like to store with this article.\n        Examples include relevant (per article) links and associated \n        Amazon items.","docstring_tokens":["Serialize","data","that","we","d","like","to","store","with","this","article",".","Examples","include","relevant","(","per","article",")","links","and","associated","Amazon","items","."],"function":"def set_associated_data(self, data):\n        \"\"\"\n        Serialize data that we'd like to store with this article.\n        Examples include relevant (per article) links and associated \n        Amazon items.\n        \"\"\"\n        import pickle\n        self.assoc_dict = pickle.dumps(data)","function_tokens":["def","set_associated_data","(","self",",","data",")",":","import","pickle","self",".","assoc_dict","=","pickle",".","dumps","(","data",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/blog.py#L89-L96"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/blog.py","language":"python","identifier":"Article.next_comment_thread_string","parameters":"(self)","argument_list":"","return_statement":"return get_thread_string(self, '')","docstring":"Returns thread string for next comment for this article","docstring_summary":"Returns thread string for next comment for this article","docstring_tokens":["Returns","thread","string","for","next","comment","for","this","article"],"function":"def next_comment_thread_string(self):\n        'Returns thread string for next comment for this article'\n        return get_thread_string(self, '')","function_tokens":["def","next_comment_thread_string","(","self",")",":","return","get_thread_string","(","self",",","''",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/blog.py#L122-L124"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/blog.py","language":"python","identifier":"Article.to_atom_xml","parameters":"(self)","argument_list":"","return_statement":"return re.sub('&(?!amp;)', '&amp;', self.html)","docstring":"Returns a string suitable for inclusion in Atom XML feed\n        \n        Internal html property should already have XHTML entities\n        converted into unicode.  However, ampersands are valid ASCII\n        and will cause issues with XML, so reconvert ampersands to\n        valid XML entities &amp;","docstring_summary":"Returns a string suitable for inclusion in Atom XML feed\n        \n        Internal html property should already have XHTML entities\n        converted into unicode.  However, ampersands are valid ASCII\n        and will cause issues with XML, so reconvert ampersands to\n        valid XML entities &amp;","docstring_tokens":["Returns","a","string","suitable","for","inclusion","in","Atom","XML","feed","Internal","html","property","should","already","have","XHTML","entities","converted","into","unicode",".","However","ampersands","are","valid","ASCII","and","will","cause","issues","with","XML","so","reconvert","ampersands","to","valid","XML","entities","&amp",";"],"function":"def to_atom_xml(self):\n        \"\"\"Returns a string suitable for inclusion in Atom XML feed\n        \n        Internal html property should already have XHTML entities\n        converted into unicode.  However, ampersands are valid ASCII\n        and will cause issues with XML, so reconvert ampersands to\n        valid XML entities &amp;\n        \"\"\"\n        import re\n        return re.sub('&(?!amp;)', '&amp;', self.html)","function_tokens":["def","to_atom_xml","(","self",")",":","import","re","return","re",".","sub","(","'&(?!amp;)'",",","'&amp;'",",","self",".","html",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/blog.py#L126-L135"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"models\/blog.py","language":"python","identifier":"Comment.next_child_thread_string","parameters":"(self)","argument_list":"","return_statement":"return get_thread_string(self.article, self.thread + '.')","docstring":"Returns thread string for next child of this comment","docstring_summary":"Returns thread string for next child of this comment","docstring_tokens":["Returns","thread","string","for","next","child","of","this","comment"],"function":"def next_child_thread_string(self):\n        'Returns thread string for next child of this comment'\n        return get_thread_string(self.article, self.thread + '.')","function_tokens":["def","next_child_thread_string","(","self",")",":","return","get_thread_string","(","self",".","article",",","self",".","thread","+","'.'",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/models\/blog.py#L168-L170"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/restful.py","language":"python","identifier":"get_sent_properties","parameters":"(request_func, propname_list)","argument_list":"","return_statement":"return prop_hash","docstring":"This maps request strings to values in a hash, optionally run through \n    a function with previous request values as parameters to the func.\n    1) key -> just read in the corresponding request value\n    2) tuple (key, func) -> Read the request value for the string key\n        and pass it through func\n    3) tuple (key, func, additional keys...) -> Get the request\n        values for the additional keys and pass them through func\n        before setting the key's value with the output.\n    If a key is not present in the request, then we do not insert a key\n    with None or empty string.  The key is simply absent, therefore allowing\n    you to use the returned hash to initial a Model instance.","docstring_summary":"This maps request strings to values in a hash, optionally run through \n    a function with previous request values as parameters to the func.\n    1) key -> just read in the corresponding request value\n    2) tuple (key, func) -> Read the request value for the string key\n        and pass it through func\n    3) tuple (key, func, additional keys...) -> Get the request\n        values for the additional keys and pass them through func\n        before setting the key's value with the output.\n    If a key is not present in the request, then we do not insert a key\n    with None or empty string.  The key is simply absent, therefore allowing\n    you to use the returned hash to initial a Model instance.","docstring_tokens":["This","maps","request","strings","to","values","in","a","hash","optionally","run","through","a","function","with","previous","request","values","as","parameters","to","the","func",".","1",")","key","-",">","just","read","in","the","corresponding","request","value","2",")","tuple","(","key","func",")","-",">","Read","the","request","value","for","the","string","key","and","pass","it","through","func","3",")","tuple","(","key","func","additional","keys","...",")","-",">","Get","the","request","values","for","the","additional","keys","and","pass","them","through","func","before","setting","the","key","s","value","with","the","output",".","If","a","key","is","not","present","in","the","request","then","we","do","not","insert","a","key","with","None","or","empty","string",".","The","key","is","simply","absent","therefore","allowing","you","to","use","the","returned","hash","to","initial","a","Model","instance","."],"function":"def get_sent_properties(request_func, propname_list):\n    \"\"\"\n    This maps request strings to values in a hash, optionally run through \n    a function with previous request values as parameters to the func.\n    1) key -> just read in the corresponding request value\n    2) tuple (key, func) -> Read the request value for the string key\n        and pass it through func\n    3) tuple (key, func, additional keys...) -> Get the request\n        values for the additional keys and pass them through func\n        before setting the key's value with the output.\n    If a key is not present in the request, then we do not insert a key\n    with None or empty string.  The key is simply absent, therefore allowing\n    you to use the returned hash to initial a Model instance.\n    \"\"\"\n    prop_hash = {}\n    for item in propname_list:\n        if isinstance(item, basestring):\n            key = item\n            value = request_func(item)\n        elif isinstance(item, tuple):\n            key = item[0]\n            prop_func = item[1]\n            if len(item) <= 2:\n                value = prop_func(request_func(key))\n            else:\n                try:\n                    addl_keys = map(prop_hash.get, item[2:])\n                    value = prop_func(*addl_keys)\n                except:\n                    return None\n        if value:\n            prop_hash[key] = value\n    return prop_hash","function_tokens":["def","get_sent_properties","(","request_func",",","propname_list",")",":","prop_hash","=","{","}","for","item","in","propname_list",":","if","isinstance","(","item",",","basestring",")",":","key","=","item","value","=","request_func","(","item",")","elif","isinstance","(","item",",","tuple",")",":","key","=","item","[","0","]","prop_func","=","item","[","1","]","if","len","(","item",")","<=","2",":","value","=","prop_func","(","request_func","(","key",")",")","else",":","try",":","addl_keys","=","map","(","prop_hash",".","get",",","item","[","2",":","]",")","value","=","prop_func","(","*","addl_keys",")","except",":","return","None","if","value",":","prop_hash","[","key","]","=","value","return","prop_hash"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/restful.py#L49-L81"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/restful.py","language":"python","identifier":"methods_via_query_allowed","parameters":"(handler_method)","argument_list":"","return_statement":"return redirect_if_needed","docstring":"A decorator to automatically re-route overloaded POSTs\n    that specify the real HTTP method in a _method query string.\n\n    To use it, decorate your post method like this:\n\n    import restful\n    ...\n    @restful.methods_via_query_allowed\n    def post(self):\n      pass\n\n    The decorator will check for a _method query string or POST argument,\n    and if present, will redirect to delete(), put(), etc.","docstring_summary":"A decorator to automatically re-route overloaded POSTs\n    that specify the real HTTP method in a _method query string.","docstring_tokens":["A","decorator","to","automatically","re","-","route","overloaded","POSTs","that","specify","the","real","HTTP","method","in","a","_method","query","string","."],"function":"def methods_via_query_allowed(handler_method):\n    \"\"\"\n    A decorator to automatically re-route overloaded POSTs\n    that specify the real HTTP method in a _method query string.\n\n    To use it, decorate your post method like this:\n\n    import restful\n    ...\n    @restful.methods_via_query_allowed\n    def post(self):\n      pass\n\n    The decorator will check for a _method query string or POST argument,\n    and if present, will redirect to delete(), put(), etc.\n    \"\"\"\n    def redirect_if_needed(self, *args, **kwargs):\n        real_verb = self.request.get('_method', None)\n        if not real_verb and 'X-HTTP-Method-Override' in self.request.environ:\n            real_verb = self.request.environ['X-HTTP-Method-Override']\n        if real_verb:\n            logging.debug(\"Redirected from POST. Detected method override = %s\", real_verb)\n            method = real_verb.upper()\n            if method == 'HEAD':\n                self.head(*args, **kwargs)\n            elif method == 'PUT':\n                self.put(*args, **kwargs)\n            elif method == 'DELETE':\n                self.delete(*args, **kwargs)\n            elif method == 'TRACE':\n                self.trace(*args, **kwargs)\n            elif method == 'OPTIONS':\n                self.head(*args, **kwargs)\n            # POST and GET included for completeness\n            elif method == 'POST':\n                self.post(*args, **kwargs)\n            elif method == 'GET':\n                self.get(*args, **kwargs)\n            else:\n                self.error(405)\n        else:\n            handler_method(self, *args, **kwargs)\n    return redirect_if_needed","function_tokens":["def","methods_via_query_allowed","(","handler_method",")",":","def","redirect_if_needed","(","self",",","*","args",",","*","*","kwargs",")",":","real_verb","=","self",".","request",".","get","(","'_method'",",","None",")","if","not","real_verb","and","'X-HTTP-Method-Override'","in","self",".","request",".","environ",":","real_verb","=","self",".","request",".","environ","[","'X-HTTP-Method-Override'","]","if","real_verb",":","logging",".","debug","(","\"Redirected from POST. Detected method override = %s\"",",","real_verb",")","method","=","real_verb",".","upper","(",")","if","method","==","'HEAD'",":","self",".","head","(","*","args",",","*","*","kwargs",")","elif","method","==","'PUT'",":","self",".","put","(","*","args",",","*","*","kwargs",")","elif","method","==","'DELETE'",":","self",".","delete","(","*","args",",","*","*","kwargs",")","elif","method","==","'TRACE'",":","self",".","trace","(","*","args",",","*","*","kwargs",")","elif","method","==","'OPTIONS'",":","self",".","head","(","*","args",",","*","*","kwargs",")","# POST and GET included for completeness","elif","method","==","'POST'",":","self",".","post","(","*","args",",","*","*","kwargs",")","elif","method","==","'GET'",":","self",".","get","(","*","args",",","*","*","kwargs",")","else",":","self",".","error","(","405",")","else",":","handler_method","(","self",",","*","args",",","*","*","kwargs",")","return","redirect_if_needed"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/restful.py#L83-L125"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/bloog\/blog.py","language":"python","identifier":"ArticleHandler.delete","parameters":"(self, path)","argument_list":"","return_statement":"","docstring":"By using DELETE on \/Article, \/Comment, \/Tag, you can delete the first \n         entity of the desired kind.\n        This is useful for writing utilities like clear_datastore.py.","docstring_summary":"By using DELETE on \/Article, \/Comment, \/Tag, you can delete the first \n         entity of the desired kind.\n        This is useful for writing utilities like clear_datastore.py.","docstring_tokens":["By","using","DELETE","on","\/","Article","\/","Comment","\/","Tag","you","can","delete","the","first","entity","of","the","desired","kind",".","This","is","useful","for","writing","utilities","like","clear_datastore",".","py","."],"function":"def delete(self, path):\n        \"\"\"\n        By using DELETE on \/Article, \/Comment, \/Tag, you can delete the first \n         entity of the desired kind.\n        This is useful for writing utilities like clear_datastore.py.  \n        \"\"\"\n        # TODO: Add DELETE for articles off root like blog entry DELETE.\n        model_class = path.lower()\n        logging.debug(\"ArticleHandler#delete on %s\", path)\n\n        def delete_entity(query):\n            targets = query.fetch(limit=1)\n            if len(targets) > 0:\n                if hasattr(targets[0], 'title'):\n                    title = targets[0].title\n                elif hasattr(targets[0], 'name'):\n                    title = targets[0].name\n                else:\n                    title = ''\n                logging.debug('Deleting %s %s', model_class, title)\n                targets[0].delete()\n                self.response.out.write('Deleted ' + model_class + ' ' + title)\n                view.invalidate_cache()\n            else:\n                self.response.set_status(204, 'No more ' + model_class + ' entities')\n                \n        if model_class == 'article':\n            query = models.blog.Article.all()\n            delete_entity(query)\n        elif model_class == 'comment':\n            query = models.blog.Comment.all()\n            delete_entity(query)\n        elif model_class == 'tag':\n            query = models.blog.Tag.all()\n            delete_entity(query)\n        else:\n            article = db.Query(models.blog.Article). \\\n                         filter('permalink =', path).get()\n            for key in article.tag_keys:\n                db.get(key).counter.decrement()\n            article.delete()\n            view.invalidate_cache()\n            restful.send_successful_response(self, \"\/\")","function_tokens":["def","delete","(","self",",","path",")",":","# TODO: Add DELETE for articles off root like blog entry DELETE.","model_class","=","path",".","lower","(",")","logging",".","debug","(","\"ArticleHandler#delete on %s\"",",","path",")","def","delete_entity","(","query",")",":","targets","=","query",".","fetch","(","limit","=","1",")","if","len","(","targets",")",">","0",":","if","hasattr","(","targets","[","0","]",",","'title'",")",":","title","=","targets","[","0","]",".","title","elif","hasattr","(","targets","[","0","]",",","'name'",")",":","title","=","targets","[","0","]",".","name","else",":","title","=","''","logging",".","debug","(","'Deleting %s %s'",",","model_class",",","title",")","targets","[","0","]",".","delete","(",")","self",".","response",".","out",".","write","(","'Deleted '","+","model_class","+","' '","+","title",")","view",".","invalidate_cache","(",")","else",":","self",".","response",".","set_status","(","204",",","'No more '","+","model_class","+","' entities'",")","if","model_class","==","'article'",":","query","=","models",".","blog",".","Article",".","all","(",")","delete_entity","(","query",")","elif","model_class","==","'comment'",":","query","=","models",".","blog",".","Comment",".","all","(",")","delete_entity","(","query",")","elif","model_class","==","'tag'",":","query","=","models",".","blog",".","Tag",".","all","(",")","delete_entity","(","query",")","else",":","article","=","db",".","Query","(","models",".","blog",".","Article",")",".","filter","(","'permalink ='",",","path",")",".","get","(",")","for","key","in","article",".","tag_keys",":","db",".","get","(","key",")",".","counter",".","decrement","(",")","article",".","delete","(",")","view",".","invalidate_cache","(",")","restful",".","send_successful_response","(","self",",","\"\/\"",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/bloog\/blog.py#L425-L467"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/bloog\/blog.py","language":"python","identifier":"MonthHandler.post","parameters":"(self, year, month)","argument_list":"","return_statement":"","docstring":"Add a blog entry. Since we are POSTing, the server handles \n            creation of the permalink url.","docstring_summary":"Add a blog entry. Since we are POSTing, the server handles \n            creation of the permalink url.","docstring_tokens":["Add","a","blog","entry",".","Since","we","are","POSTing","the","server","handles","creation","of","the","permalink","url","."],"function":"def post(self, year, month):\n        \"\"\" Add a blog entry. Since we are POSTing, the server handles \n            creation of the permalink url. \"\"\"\n        logging.debug(\"MonthHandler#post on date %s, %s\", year, month)\n        process_article_submission(handler=self, article_type='blog entry')","function_tokens":["def","post","(","self",",","year",",","month",")",":","logging",".","debug","(","\"MonthHandler#post on date %s, %s\"",",","year",",","month",")","process_article_submission","(","handler","=","self",",","article_type","=","'blog entry'",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/bloog\/blog.py#L571-L575"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/shell\/shell.py","language":"python","identifier":"ShellSession.set_global","parameters":"(self, name, value)","argument_list":"","return_statement":"","docstring":"Adds a global, or updates it if it already exists.\n\n    Also removes the global from the list of unpicklable names.\n\n    Args:\n      name: the name of the global to remove\n      value: any picklable value","docstring_summary":"Adds a global, or updates it if it already exists.","docstring_tokens":["Adds","a","global","or","updates","it","if","it","already","exists","."],"function":"def set_global(self, name, value):\n    \"\"\"Adds a global, or updates it if it already exists.\n\n    Also removes the global from the list of unpicklable names.\n\n    Args:\n      name: the name of the global to remove\n      value: any picklable value\n    \"\"\"\n    blob = db.Blob(pickle.dumps(value))\n\n    if name in self.global_names:\n      index = self.global_names.index(name)\n      self.globals[index] = blob\n    else:\n      self.global_names.append(db.Text(name))\n      self.globals.append(blob)\n\n    self.remove_unpicklable_name(name)","function_tokens":["def","set_global","(","self",",","name",",","value",")",":","blob","=","db",".","Blob","(","pickle",".","dumps","(","value",")",")","if","name","in","self",".","global_names",":","index","=","self",".","global_names",".","index","(","name",")","self",".","globals","[","index","]","=","blob","else",":","self",".","global_names",".","append","(","db",".","Text","(","name",")",")","self",".","globals",".","append","(","blob",")","self",".","remove_unpicklable_name","(","name",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/shell\/shell.py#L108-L126"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/shell\/shell.py","language":"python","identifier":"ShellSession.remove_global","parameters":"(self, name)","argument_list":"","return_statement":"","docstring":"Removes a global, if it exists.\n\n    Args:\n      name: string, the name of the global to remove","docstring_summary":"Removes a global, if it exists.","docstring_tokens":["Removes","a","global","if","it","exists","."],"function":"def remove_global(self, name):\n    \"\"\"Removes a global, if it exists.\n\n    Args:\n      name: string, the name of the global to remove\n    \"\"\"\n    if name in self.global_names:\n      index = self.global_names.index(name)\n      del self.global_names[index]\n      del self.globals[index]","function_tokens":["def","remove_global","(","self",",","name",")",":","if","name","in","self",".","global_names",":","index","=","self",".","global_names",".","index","(","name",")","del","self",".","global_names","[","index","]","del","self",".","globals","[","index","]"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/shell\/shell.py#L128-L137"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/shell\/shell.py","language":"python","identifier":"ShellSession.globals_dict","parameters":"(self)","argument_list":"","return_statement":"return dict((name, pickle.loads(val))\n                for name, val in zip(self.global_names, self.globals))","docstring":"Returns a dictionary view of the globals.","docstring_summary":"Returns a dictionary view of the globals.","docstring_tokens":["Returns","a","dictionary","view","of","the","globals","."],"function":"def globals_dict(self):\n    \"\"\"Returns a dictionary view of the globals.\n    \"\"\"\n    return dict((name, pickle.loads(val))\n                for name, val in zip(self.global_names, self.globals))","function_tokens":["def","globals_dict","(","self",")",":","return","dict","(","(","name",",","pickle",".","loads","(","val",")",")","for","name",",","val","in","zip","(","self",".","global_names",",","self",".","globals",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/shell\/shell.py#L139-L143"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/shell\/shell.py","language":"python","identifier":"ShellSession.add_unpicklable","parameters":"(self, statement, names)","argument_list":"","return_statement":"","docstring":"Adds a statement and list of names to the unpicklables.\n\n    Also removes the names from the globals.\n\n    Args:\n      statement: string, the statement that created new unpicklable global(s).\n      names: list of strings; the names of the globals created by the statement.","docstring_summary":"Adds a statement and list of names to the unpicklables.","docstring_tokens":["Adds","a","statement","and","list","of","names","to","the","unpicklables","."],"function":"def add_unpicklable(self, statement, names):\n    \"\"\"Adds a statement and list of names to the unpicklables.\n\n    Also removes the names from the globals.\n\n    Args:\n      statement: string, the statement that created new unpicklable global(s).\n      names: list of strings; the names of the globals created by the statement.\n    \"\"\"\n    self.unpicklables.append(db.Text(statement))\n\n    for name in names:\n      self.remove_global(name)\n      if name not in self.unpicklable_names:\n        self.unpicklable_names.append(db.Text(name))","function_tokens":["def","add_unpicklable","(","self",",","statement",",","names",")",":","self",".","unpicklables",".","append","(","db",".","Text","(","statement",")",")","for","name","in","names",":","self",".","remove_global","(","name",")","if","name","not","in","self",".","unpicklable_names",":","self",".","unpicklable_names",".","append","(","db",".","Text","(","name",")",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/shell\/shell.py#L145-L159"}
{"nwo":"DocSavage\/bloog","sha":"ba3e32209006670fbac1beda1e3b631608c2b6cb","path":"handlers\/shell\/shell.py","language":"python","identifier":"ShellSession.remove_unpicklable_name","parameters":"(self, name)","argument_list":"","return_statement":"","docstring":"Removes a name from the list of unpicklable names, if it exists.\n\n    Args:\n      name: string, the name of the unpicklable global to remove","docstring_summary":"Removes a name from the list of unpicklable names, if it exists.","docstring_tokens":["Removes","a","name","from","the","list","of","unpicklable","names","if","it","exists","."],"function":"def remove_unpicklable_name(self, name):\n    \"\"\"Removes a name from the list of unpicklable names, if it exists.\n\n    Args:\n      name: string, the name of the unpicklable global to remove\n    \"\"\"\n    if name in self.unpicklable_names:\n      self.unpicklable_names.remove(name)","function_tokens":["def","remove_unpicklable_name","(","self",",","name",")",":","if","name","in","self",".","unpicklable_names",":","self",".","unpicklable_names",".","remove","(","name",")"],"url":"https:\/\/github.com\/DocSavage\/bloog\/blob\/ba3e32209006670fbac1beda1e3b631608c2b6cb\/handlers\/shell\/shell.py#L161-L168"}