示例#1
0
def walk(top, options=DictWalkOptions.values_only):
    from vyperlogix import misc
    try:
        __stack__ = []
        options = options if ((options) and
                              (options.value)) else DictWalkOptions.values_only
        while (1):
            top = [top] if (not misc.isIterable(top)) else [top] if (
                misc.isDict(top)) else top
            for t in top:
                for k, v in t.iteritems():
                    __is__ = misc.isDict(v) or misc.isHashedDict(v[0] if (
                        misc.isIterable(v)) else v)
                    if (__is__):
                        __stack__.append(v)
                    if (options) and (options.value):
                        if (options.value
                                & DictWalkOptions.keys_and_values.value):
                            yield (k, v)
                        elif (options.value & DictWalkOptions.keys_only.value):
                            yield k if (__is__) else v
                        elif (options.value
                              & DictWalkOptions.values_only.value):
                            if (__is__):
                                continue
                            else:
                                yield v
                    else:
                        yield k if (misc.isDict(v)) else v
            top = __stack__.pop() if (len(__stack__) > 0) else None
            if (not top):
                raise StopIteration
    except:
        raise StopIteration
    raise StopIteration
示例#2
0
    def store_in_bucket_recursive(bucket={}, fp=None):
        def packit(fp):
            toks = [t for t in fp.split('/') if t]
            ret = fp
            for tok in reversed(toks):
                ret = {tok: ret}
            return ret

        def merge(d1, d2):
            for k1, v1 in d1.iteritems():
                if not k1 in d2:
                    d2[k1] = v1
                elif isinstance(v1, dict):
                    merge(v1, d2[k1])
            return d2

        if (not fp):
            paths = ['1/2/3', '1/2/4', '1/2/5']
        else:
            paths = [fp] if (not misc.isList(fp)) else fp
        dicts = [packit(p) for p in paths]
        merged = bucket if (misc.isDict(bucket)) else {}
        for d in dicts:
            merged = merge(merged, d)
        return merged
示例#3
0
 def merge(d1, d2):
     for k1, v1 in d1.iteritems():
         if not k1 in d2:
             d2[k1] = v1
         elif misc.isDict(v1):
             merge(v1, d2[k1])
     return d2
    def store_in_bucket_recursive(bucket={},fp=None):

        def packit(fp):
            toks = [t for t in fp.split('/') if t]
            ret = fp
            for tok in reversed(toks):
                ret = {tok: ret}
            return ret
        
        def merge(d1, d2):
            for k1,v1 in d1.iteritems():
                if not k1 in d2:
                    d2[k1] = v1
                elif isinstance(v1, dict):
                    merge(v1, d2[k1])
            return d2

        if (not fp):
            paths = ['1/2/3','1/2/4','1/2/5']
        else:
            paths = [fp] if (not misc.isList(fp)) else fp
        dicts = [packit(p) for p in paths]
        merged = bucket if (misc.isDict(bucket)) else {}
        for d in dicts:
            merged = merge(merged,d)
        return merged
示例#5
0
文件: g.py 项目: raychorn/knowu
def __context__(request,data=None):
    __data__ = {
        "url": request.META.get('PATH_INFO','/'),
        "siteurl":"http://djangononrelsample2.vyperlogix.com",
        "sitename": "djangononrelsample2™",
        "services": "VyperLogix",
        "company": "VyperLogix",
        "sitename2": "The djangononrelsample2™"
    }
    if (misc.isDict(data)):
        for k,v in data.iteritems():
            __data__[k] = v
    return __data__
示例#6
0
 def process_request(self, request):
     """
         This is run for every request, it checks to see if it can get a
         defined item out of the cache, if that fails it tries to set it
         Failing that it decides the server is probably crashed, but
         goes though and attempts to connect to the server. Failing a connection
         It will launch a new server.
     """
     if not misc.isDict(self.results) or (not self.results.has_key('ok')) or (self.results['ok'] < 1):
         # Later-on we will be wanting to make sure the Sleepy Mongoose is also running...
         logging.warning('mongod service is not running, start it !')
         self.__restart_service__(self.mongodb_service_name)
         return None
         
     return None
示例#7
0
文件: g.py 项目: raychorn/knowu
def queue_email(email_from,email_to,email_subject,email_body,email_body_html,__air_id__,is_html=False,data={},error_symbol=None):
    ''' See also: settings.py for the following:
    EMAIL_BACKEND = 'django_mailgun.MailgunBackend'
    MAILGUN_ACCESS_KEY = 'key-50npnx4bhglbohd-f60k00ottnzop6a8'
    MAILGUN_SERVER_NAME = 'vyperlogix.com'
    '''
    try:
	from django.core import mail
	connection = mail.get_connection()
	connection.open()
	email1 = mail.EmailMessage(email_subject, email_body, email_from, [email_to], connection=connection)
	email1.send()
	connection.close()
    except Exception, ex:
	__queue_email__(email_from,email_to,email_subject,email_body,email_body_html,__air_id__,is_html=True,data=data,error_symbol=error_symbol)
	if (error_symbol):
	    if (misc.isDict(data) and not data.has_key(error_symbol)):
		data[error_symbol] = _utils.formattedException(details=ex)
示例#8
0
 def __getattr__(self, name):
     value = super(API, self).__getattr__(name)
     if (value is None) or (len(value) == 0):  # and (name != '/'):
         _d_ = HashedFuzzySmartLists({})
         _values_ = []
         for k in self.keys():
             if (misc.isDict(super(API, self).__getattr__(k))) and (super(
                     API, self).__getattr__(k).has_key('url')):
                 _k_ = super(API, self).__getattr__(k)['url'].replace(
                     '/' + k.split('@')[0], '')
                 _d_[_k_] = SmartFuzzyObject(
                     super(API, self).__getattr__(k))
         l = ListWrapper(_d_.keys())
         _name_ = name.split(API.make_key('', ''))[-1]
         if (not self.__specific__):
             while (len(_name_) > 0):
                 _list_ = l.findAllContaining(_name_) if (
                     _name_ != '/') else l.findAllMatching(_name_)
                 _items_ = [
                     item for item in _list_ if (item.endswith(_name_))
                 ]
                 x = l.findFirstMatching(_items_[0] if (
                     len(_items_) > 0) else _name_) if (
                         (len(_list_) > 0) or
                         (_name_ == '/')) else l.findFirstContaining(
                             _items_[0] if (len(_items_) > 0) else _name_)
                 if (x > -1):
                     for v in _d_[l[x]]:
                         _values_.append(v)
                     break
                 else:
                     x = l.findFirstContaining(_name_)
                     if (x > -1):
                         for v in _d_[l[x]]:
                             _values_.append(v)
                         break
                     else:
                         _l_ = _name_.split('/')
                         del _l_[-2 if (len(_l_[-1]) == 0) else -1]
                         _name_ = '/'.join(_l_)
     return value if (len(_values_) == 0) else _values_
示例#9
0
文件: g.py 项目: raychorn/knowu
def send_php_email(url,parms={},is_html=False,data={},error_symbol=None):
    import urllib,urllib2

    content = ''
    try:
	__data__ = data # don't worry this line works...
	data = {}
	logging.warning('send_php_email().1 --> parms=%s' % (parms))
	if (len(parms.keys()) > 0):
	    _expected_keys = ['to','subject','body','altbody']
	    for k,v in parms.iteritems():
		if (k == 'altbody'):
		    data[k] = (v.replace('\n','').replace('\r','').replace("\'",'') if (k in _expected_keys) else '')
		else:
		    data[k] = (v.replace("\'",'') if (k in _expected_keys) else '')
	else:
	    data = {'to':'*****@*****.**', 'subject':'This is a test...', 'body':'<p>This is <b>just</b> a test...</p>', 'altbody':'This is just a test...'}
	logging.warning('send_php_email().2 --> data=%s' % (data))
	data = urllib.urlencode(data)
    
	user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
	headers = {'User-Agent':user_agent}
    
	req = urllib2.Request(url, data, headers)
	response = urllib2.urlopen(req)
	content = response.read()
	logging.warning('send_php_email().3 --> content=%s' % (content))
    except Exception, e:
	toks = ListWrapper(str(e).split())
	f = toks.findFirstContaining(']')
	message = 'send_php_email().ERROR --> "%s".' % (str(e))
	message2 = 'send_php_email().ERROR --> "%s".' % (' '.join(toks[f+1:f+1+5]+'...') if (f > -1) else str(e))
	if (error_symbol):
	    if (misc.isDict(__data__)):
		__data__[error_symbol] = message2
	logging.warning(message)
示例#10
0
def default(request,
            _get_user=None,
            domain='localhost',
            secure_endpoint='http://localhost',
            insecure_endpoint='http://localhost',
            air_id=None,
            air_version={},
            apiMap=None,
            logging=None,
            callback=None):
    try:
        __apiMap__ = apiMap if (apiMap.isAPI) else API({}, secure_endpoint,
                                                       insecure_endpoint)
    except:
        __apiMap__ = API({}, secure_endpoint, insecure_endpoint)
    qryObj = django_utils.queryObject(request)
    parms = django_utils.parse_url_parms(request)
    context = RequestContext(request)

    __domainName = domain

    try:
        _user = __get_user__(request) if (
            _get_user is None) else _get_user(request)
    except:
        user = __default_superuser__()
    u = request.session.get('user')
    if (u):
        _user = u
    if (misc.isDict(_user)):
        _user = SmartFuzzyObject(_user)
    _is_method_post_ = django_utils.is_method_post(request)

    is_logging_info = (logging is not None)
    if (logging is not None):
        logging.info('(+++) is_logging_info=%s' % (is_logging_info))

    is_html = lambda url: (url.endswith('.html')) or (url.endswith('.htm'))

    try:
        s_response = ''
        __error__ = ''

        url = '/%s%s' % (str('/'.join(parms)), '/' if
                         ((len(parms) > 0) and
                          (not is_html(parms[-1]))) else '')

        if (is_logging_info):
            logging.info('(1) url=%s' % (url))
        elif (settings.IS_PRODUCTION_SERVER):
            print '(1) url=%s' % (url)

        if (url.find('/activate/') > -1):
            toks = ListWrapper(url.split('/'))
            i = toks.findFirstMatching('activate')
            if (i > -1):
                del toks[i + 1]
            url = '/'.join(toks)

        browserAnalysis = django_utils.get_browser_analysis(
            request, parms, any([]))

        _current_site = __domainName
        _current_site = _current_site.replace('.appspot',
                                              '').replace('.com', '').lower()

        aid = parms[-1] if (len(parms) > 0) else ''

        get_value_from = lambda value, key, default: value[key] if (v.has_key(
            key)) else default

        __isUsingChrome__ = (str(
            browserAnalysis.browserName).lower() == 'Chrome'.lower())
        __isUsingOpera__ = (str(
            browserAnalysis.browserName).lower() == 'Opera'.lower())
        __isUsingFireFox__ = (str(
            browserAnalysis.browserName).lower() == 'FireFox'.lower())
        _data = {
            'HTTP_USER_AGENT':
            django_utils.get_from_META(request, 'HTTP_USER_AGENT', ''),
            'browserName':
            browserAnalysis.browserName,
            'browserVersion':
            browserAnalysis.browserVersion,
            'isRunningLocal':
            browserAnalysis.isRunningLocal(request),
            'isJavaScriptOptimized':
            browserAnalysis.isJavaScriptOptimized,
            'isUsingUnsupportedBrowser':
            browserAnalysis.isUsingUnsupportedBrowser,
            'isUsingMSIE':
            browserAnalysis.isUsingMSIE,
            'isBrowserWebKit':
            browserAnalysis.isBrowserWebKit,
            'isUsingAndroid':
            browserAnalysis.isUsingAndroid,
            'isUsingChrome':
            __isUsingChrome__,
            'isUsingOpera':
            __isUsingOpera__,
            'isUsingFireFox':
            __isUsingFireFox__,
            'isUsingChromeOrWebKit': (__isUsingChrome__)
            or (browserAnalysis.isBrowserWebKit),
            'qryObj':
            qryObj,
            'serial':
            str(uuid.uuid4()),
            'isShowingFlash':
            True,
            'isShowingTitleBar':
            True,
            'is_superuser':
            _user.is_superuser,
            'secure_endpoint':
            secure_endpoint,
            'insecure_endpoint':
            insecure_endpoint,
            'request_endpoint':
            secure_endpoint if
            (django_utils.is_request_HTTPS(request)) else insecure_endpoint,
            'version':
            air_version[air_id] if (air_version[air_id]) else settings.VERSION,
            'air_id':
            air_id,
            'apiMap':
            dict([(' '.join(
                [str(s).capitalize() for s in k.split('@')[-1].split('_')]), [
                    get_value_from(v, 'url',
                                   '').replace('/' + k.split('@')[0], ''),
                    get_value_from(v, 'isPostRequired', False),
                    get_value_from(v, 'fields', [])
                ]) for k, v in __apiMap__.asPythonDict().iteritems()
                  if (len(k.split('@')) == 2)])
        }
        try:
            _data['IS_NOT_LOGGED_IN'] = settings.IS_NOT_LOGGED_IN if (
                not _user) else (len(_user.is_authenticated) == 0) if (
                    misc.isList(_user.is_authenticated)
                ) else not _user.is_authenticated
        except:
            _data['IS_NOT_LOGGED_IN'] = False
        try:
            _data['IS_LOGGED_IN'] = not _data['IS_NOT_LOGGED_IN']
        except:
            _data['IS_LOGGED_IN'] = False
        try:
            _data['USER_NAME'] = _user.name if (
                _user and _data['IS_LOGGED_IN']) else 'Anonymous'
        except:
            _data['IS_NOT_LOGGED_IN'] = False
        try:
            _data[
                'IS_PRODUCTION_WEB_SERVER'] = settings.IS_PRODUCTION_WEB_SERVER
        except:
            _data['IS_PRODUCTION_WEB_SERVER'] = False
        try:
            _data[
                'IS_NOT_PRODUCTION_WEB_SERVER'] = settings.IS_NOT_PRODUCTION_WEB_SERVER
        except:
            _data['IS_NOT_PRODUCTION_WEB_SERVER'] = False
        _data['AVAILABLE_AUTH_METHODS'] = []
        try:
            from users.g import AuthMethods
            for n, v in AuthMethods:
                e = AuthMethods(n)
                if (e.value > 0):
                    if (e.value == 1):
                        _data[
                            'IS_DJANGO_AUTH_METHOD'] = AuthMethods.django.value > 0
                        _data['AVAILABLE_AUTH_METHODS'].append(
                            'IS_DJANGO_AUTH_METHOD')
                    else:
                        k = 'IS_%s_AUTH_METHOD' % (n.upper())
                        _data[k] = e.value > 0
                        _data['AVAILABLE_AUTH_METHODS'].append(k)
        except:
            _data['IS_DJANGO_AUTH_METHOD'] = True
            _data['AVAILABLE_AUTH_METHODS'].append('IS_DJANGO_AUTH_METHOD')
        if (is_logging_info):
            logging.info('(1.1) _data=%s' % (str(_data)))
        for k, v in request.session.iteritems():
            _data[k] = v
        if (is_logging_info):
            logging.info('(1.2) _data=%s' % (str(_data)))

        air_id = parms[-1].split('.')[0] if (
            len(parms) > 0
        ) else ''  # avoid the key error that would be caused without this line of code...

        if (is_logging_info):
            logging.info('(5) air_id=%s' % (air_id))
            logging.info('(5.1) _data=%s' % (str(_data)))

        _is_callable_ = lambda v: any([callable(x.func) for x in v]) if (
            misc.isList(v)) else callable(v.func)

        __apiMap__.__specific__ = is_html(url)
        m = __apiMap__[url]
        isUrlMapped = (m != None) and (m != []) and (_is_callable_(m))
        if (not isUrlMapped):
            if (not is_html(url)):
                url = '/%s%s' % (str('/'.join(parms[0:-1])), '/' if
                                 (len(parms[0:-1]) > 0) else '')
            m = __apiMap__[url]
            isUrlMapped = (m != None) and (m != []) and (_is_callable_(m))
            if (isUrlMapped):
                air_id = aid

                if (is_logging_info):
                    logging.info('(6) air_id=%s' % (air_id))

                if (settings.IS_PRODUCTION_SERVER):
                    settings.DOMAIN_NAME = settings.APPSPOT_NAME = air_domain[
                        air_id]
            else:
                _m_ = [
                    k for k in air_version.keys() if ((len(aid) > 0) and (
                        (aid.lower().find(k.lower()) > -1) or
                        (k.lower().find(aid.lower()) > -1))) or (
                            k.lower().find(_current_site) > -1) or (
                                _current_site.lower().find(k.lower()) > -1)
                ]
                air_id = _m_[0] if (len(_m_) > 0) else air_id

                if (is_logging_info):
                    logging.info('(7) air_id=%s, _m_=%s, aid=%s' %
                                 (air_id, _m_, aid))

        http_host = django_utils.get_from_META(request,
                                               'HTTP_HOST',
                                               default='')
        if (__apiMap__.__secure_endpoint__.find('127.0.0.1') >
                -1) and (http_host.find('localhost') > -1):
            http_host = http_host.replace('localhost', '127.0.0.1')
        http_host = http_host.split(':')[0]
        _is_http_host_correct_ = True if (
            not settings.IS_HTTPS_REQUIRED) else (
                __apiMap__.__secure_endpoint__.find(http_host) > -1)
        _is_request_correct_ = ((not settings.IS_PRODUCTION_SERVER)
                                or (not settings.IS_HTTPS_REQUIRED)
                                or ((settings.IS_PRODUCTION_SERVER) and
                                    (django_utils.is_request_HTTPS(request))))

        def __resolve_mapping_from_rules__(m, qryObj):
            for mm in m:
                _rules_ = [
                    r for r in [(str(k).split('_'), k) for k in mm.keys()]
                    if (str(r[0][0]).lower() == 'rules') and (len(r[0]) == 2)
                ]
                _has_rules_ = any([len(r[0]) == 2 for r in _rules_])
                _is_rules_ = False
                if (_has_rules_):
                    rCnt = 0
                    for r in _rules_:
                        try:
                            obj = eval(r[0][-1])
                            if (obj):
                                val = mm[r[-1]]
                                if (val):
                                    for k, v in val.iteritems():
                                        if (obj[k] == v):
                                            rCnt += 1
                                            m = mm
                                            _is_rules_ = True
                                            isUrlMapped = True
                                            return isUrlMapped, m, _has_rules_
                                        else:
                                            _re_ = re.compile(v)
                                            if (_re_.match(obj[k])):
                                                rCnt += 1
                                                m = mm
                                                _is_rules_ = True
                                                isUrlMapped = True
                                                return isUrlMapped, m, _has_rules_
                        except:
                            pass
                    if (rCnt < 1):
                        isUrlMapped = False
                else:
                    m = m[0]
                    isUrlMapped = True
                    return isUrlMapped, m, _has_rules_
            return False, m, False

        isUrlMapped, m, _has_rules_ = __resolve_mapping_from_rules__(m, qryObj)
        _is_method_correct_ = ((isUrlMapped)) and (
            ((m.isPostRequired) and _is_method_post_) or
            ((not m.isPostRequired) and not _is_method_post_))
        if (is_logging_info):
            logging.info('(7.0) http_host=%s' % (http_host))
            logging.info('(7.1) isUrlMapped=%s' % (isUrlMapped))
            try:
                logging.info('(7.2) m.isPostRequired=%s' % (m.isPostRequired))
            except:
                pass
            logging.info('(7.3) _is_method_post_=%s' % (_is_method_post_))
            logging.info('(7.3.1) _is_method_correct_=%s' %
                         (_is_method_correct_))
            logging.info('(7.3.2) _is_http_host_correct_=%s, http_host=%s' %
                         (_is_http_host_correct_, http_host))
            logging.info('(7.3.3) _is_request_correct_=%s' %
                         (_is_request_correct_))
            logging.info('(7.3.4) _has_rules_=%s' % (_has_rules_))

            logging.info('(7.4) __apiMap__.__secure_endpoint__=%s' %
                         (__apiMap__.__secure_endpoint__))
            logging.info('(7.5) settings.IS_PRODUCTION_SERVER=%s' %
                         (settings.IS_PRODUCTION_SERVER))
            logging.info('(7.5.1) settings.IS_HTTPS_REQUIRED=%s' %
                         (settings.IS_HTTPS_REQUIRED))
            logging.info('(7.6) django_utils.is_request_HTTPS(request)=%s' %
                         (django_utils.is_request_HTTPS(request)))
            logging.info(
                '(7.7) django_utils.get_from_environ(request,\'SERVER_PORT\',80)=%s'
                % (django_utils.get_from_environ(request, 'SERVER_PORT', 80)))
            logging.info(
                '(7.8) django_utils.is_Production()=%s, django_utils.is_Staging()=%s'
                % (django_utils.is_Production(request),
                   django_utils.is_Staging(request)))
        if (isUrlMapped) and (_is_method_correct_) and (
                _is_http_host_correct_
        ) and (
                _is_request_correct_
        ):  # (must be mapped), (must use POST), (must use secure endpoint) and (if production must use SSL).
            if (is_logging_info):
                logging.info('(8.0) !!!')
            try:
                response = m.func(request,
                                  parms,
                                  browserAnalysis,
                                  air_id,
                                  __apiMap__,
                                  data=_data)
                if (is_logging_info):
                    logging.info('(8) response=%s' % (response))
                    logging.info('(9) settings.APP_SESSION_KEY=%s' %
                                 (settings.APP_SESSION_KEY))
                django_utils.give_response_session_id_using(
                    request, response, settings.APP_SESSION_KEY)
                return response
            except Exception as e:
                info_string = _utils.formattedException(details=e)
                logging.info('%s' % (info_string))
            return django_utils.render_main_html(
                request,
                browserAnalysis,
                qryObj,
                data=_data,
                is_logging_info=is_logging_info,
                current_site=_current_site,
                aid=aid,
                air_id=air_id,
                logging=logging,
                context=context)
        if (air_version[air_id] is None):
            try:
                _message = django_utils.get_from_post_or_get(
                    request, 'message', '')
                if (len(_message) > 0):
                    _data['message'] = _message
                _url_ = os.sep + os.sep.join(
                    [c for c in url.split('/') if (len(c) > 0)])
                _s_ = os.sep.join([settings.MEDIA_ROOT, _url_])
                if (os.path.isfile(_s_)) and (os.path.exists(_s_)):
                    _url_ = '/static/' + '/'.join(
                        [c for c in url.split('/') if (len(c) > 0)])
                    try:
                        return HttpResponseRedirect(
                            _url_
                        )  # allow the web server to handle this rather than the application server...
                    except:
                        pass
                    return django_static.serve(
                        _s_
                    )  # if all else fails the application server should handle the request...
                _url_ = '/'.join(
                    url.split('/')[1 if (url.startswith('/')) else 0:])
                if (callable(callback)):
                    try:
                        response = callback(request, _url_, _data)
                        if (isinstance(response, HttpResponseRedirect)):
                            return response
                    except:
                        logging.exception('%s' % (_url_))
                return render_to_response(_url_,
                                          _data,
                                          context_instance=context)
            except TemplateDoesNotExist, e:
                try:
                    _url_ += 'index.htm'
                    if (callable(callback)):
                        try:
                            callback(request,
                                     _url_,
                                     _data,
                                     context_instance=context)
                        except:
                            pass
                    return render_to_response(_url_,
                                              _data,
                                              context_instance=context)
                except TemplateDoesNotExist, e:
                    try:
                        _url_ += 'l'
                        if (callable(callback)):
                            try:
                                callback(request,
                                         _url_,
                                         _data,
                                         context_instance=context)
                            except:
                                pass
                        return render_to_response(_url_,
                                                  _data,
                                                  context_instance=context)
                    except TemplateDoesNotExist, e:
                        info_string = _utils.formattedException(details=e)
                        logging.info('%s' % (info_string))
示例#11
0
文件: views.py 项目: raychorn/knowu
from django.conf import settings

from django.shortcuts import render_to_response

from g import __context__

import re
import json

from vyperlogix import misc

from django.contrib.auth.models import AnonymousUser

from models import JsonData

get_user = lambda r:r.session.get('__user__', AnonymousUser) if (r and misc.isDict(r.session)) else AnonymousUser

def default(request):
    context = __context__(request)
    current_user = get_user(request)
    context['IS_NOT_LOGGED_IN'] = current_user is AnonymousUser
    return render_to_response('main.html', context, content_type="text/html")

def data(request):
    context = __context__(request)
    current_user = get_user(request)
    context['IS_NOT_LOGGED_IN'] = current_user is AnonymousUser
    context['current_user'] = current_user
    items = JsonData.objects.order_by('statename').all()
    has_database = len(items) > 0
    context['action'] = '/createdata/' if (not has_database) else ''
示例#12
0
USE AT YOUR OWN RISK.
"""
import logging

import urllib2

import simplejson

from vyperlogix import misc
from vyperlogix.misc import _utils
from vyperlogix.classes import MagicObject

arg0 = lambda args: args[0] if (misc.isIterable(args)) and (len(
    args) > 0) and (misc.isString(args[0])) else None
list0 = lambda args: args[0] if (misc.isIterable(args)) and (len(
    args) > 0) and ((misc.isList(args[0])) or (misc.isDict(args[0]))) else []
int0 = lambda args: args[0] if (misc.isIterable(args)) and (len(
    args) > 0) and (misc.isInteger(args[0])) else None
bool0 = lambda args: args[0] if (misc.isIterable(args)) and (len(
    args) > 0) and (misc.isBooleanString(args[0])) else None

__only__ = lambda value, target: value if (str(value).lower().capitalize(
) == str(target).lower().capitalize()) else None


class SleepyMongoose(MagicObject.MagicObject2):
    def __init__(self, sleepy_mongoose):
        '''
        See also: https://github.com/kchodorow/sleepy.mongoose/wiki/
        '''
        toks = sleepy_mongoose.split(':')