Exemplo n.º 1
0
def jstree(json):
    result = []
    if isinstance(json, dict):
        for k, v in json.iteritems():
            a = random.uniform(0, 10)
            if not isinstance(v, dict) and not isinstance(v, list):
                if len(v) > 60 and r'://' in v:
                    temp = v
                    pos = temp.index(r'://')
                    content = temp[0:pos + 3] + "..." + temp[-57:]
                    result.append({
                        "id": k + str(a),
                        "text": str(k) + ":" + content
                    })
                else:
                    result.append({
                        "id": k + str(a),
                        "text": str(k) + ":" + str(v)
                    })
            else:
                chstr = jstree(v)
                result.append({"id": k + str(a), "text": k, "children": chstr})
    elif isinstance(json, list):
        for v in json:
            a = random.uniform(0, 10)
            if not isinstance(v, dict) and not isinstance(v, list):
                result.append({"id": v + str(a), "text": v})
            else:
                chstr = jstree(v)
                result.append({"id": str(a), "text": "--", "children": chstr})
    result_sorted = sorted(result, key=operator.itemgetter('text'))
    return result_sorted
Exemplo n.º 2
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "space": "        ",
        "id": format_id,
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)

    return format_entry_template.format(**parsed)
Exemplo n.º 3
0
	def _store(json):
		'return the head domain object update with all sub-domain (or derivate)'
		
		#1 - first top-level object creation
		D=eval("%(_type)s('%(name)s',path='%(domain)s')"%json)

		#2 - sub-domain creation &ref
		dir=json['dir']
		if dir : #this is a not a leaf then.
			for name in dir :
				dir[name]=domain._store(dir[name])
		
		#3 - Parent domain reference
		D.domain=domain.find(json['domain'])
		
		#4 - stuff attributes General
		for attr in ('dir','domain') : 
			del json[attr]
		D.__dict__.update(json)
		
		print D
		
		#4 - stuff **custom** attributes conversion
		f=D.__class__._attr_conv
		for k,attr in json.iteritems():
		 	if k in f :
				if isinstance(attr,str):
					D.__dict__[k]=eval("%s('%s')" % (f[k][0],attr))
				else:
					D.__dict__[k]=eval('%s(%s)' % (f[k][0],attr))
				
		return D
def json_to_table_data(format_name, prefix, json):

    table_data = ""

    parsed = {
        "space": "        ",
        "formatName": format_name,
        "texFormat": "DXGI_FORMAT_UNKNOWN",
        "srvFormat": "DXGI_FORMAT_UNKNOWN",
        "rtvFormat": "DXGI_FORMAT_UNKNOWN",
        "dsvFormat": "DXGI_FORMAT_UNKNOWN",
        "glInternalFormat": "GL_NONE",
        "condition": prefix,
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if (format_name != "ANGLE_FORMAT_NONE") and (parsed["glInternalFormat"] == "GL_NONE"):
        print("Missing 'glInternalFormat' from " + format_name)
        sys.exit(1)

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    # Derived values.
    parsed["blitSRVFormat"] = get_blit_srv_format(parsed)
    parsed["swizzleFormat"] = get_swizzle_format_id(format_name, parsed)
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)

    if len(prefix) > 0:
        return split_format_entry_template.format(**parsed)
    else:
        return format_entry_template.format(**parsed)
Exemplo n.º 5
0
def json_to_table_data(internal_format, format_name, prefix, json):

    table_data = ""

    parsed = {
        "space": "        ",
        "internalFormat": internal_format,
        "formatName": format_name,
        "texFormat": "DXGI_FORMAT_UNKNOWN",
        "srvFormat": "DXGI_FORMAT_UNKNOWN",
        "uavFormat": "DXGI_FORMAT_UNKNOWN",
        "rtvFormat": "DXGI_FORMAT_UNKNOWN",
        "dsvFormat": "DXGI_FORMAT_UNKNOWN",
        "condition": prefix,
    }

    for k, v in json.iteritems():
        parsed[k] = v

    # Derived values.
    parsed["blitSRVFormat"] = get_blit_srv_format(parsed)
    parsed["swizzleFormat"] = get_swizzle_format_id(internal_format, parsed)
    parsed["initializer"]   = angle_format.get_internal_format_initializer(
        internal_format, parsed["formatName"])

    if len(prefix) > 0:
        return split_format_entry_template.format(**parsed)
    else:
        return format_entry_template.format(**parsed)
Exemplo n.º 6
0
def addClassFromJson(json, objColl, className, conf):
    classDef = None
    if className is not None:
        className = conf.mapClassName(className)
        classDef = SupaDupaClassDef.SupaDupaClassDef(className)
        objColl[className] = classDef
    for k,v in json.iteritems():
        proccessedKey = conf.mapKey(k)
        if conf.classOverrideForProp(proccessedKey) is not None:
            override = conf.classOverrideForProp(proccessedKey)
            classDef.addProperty(proccessedKey, 
                                 conf.getWriteClass().formatClassName(override))
        elif isinstance(v, dict):
            formattedClassName = conf.getWriteClass().formatClassName(k)
            if classDef is not None:
                containedClassName = conf.mapClassName(formattedClassName)
                classDef.addProperty(proccessedKey, containedClassName)
                classDef.addDependency(containedClassName)
            addClassFromJson(v, objColl, formattedClassName, conf)
        elif isinstance(v, list):
            classDef.addProperty(proccessedKey, getClassNameFromWriter(list, conf))
            if len(v) > 0:
                addClassFromJson(v[0], objColl, 
                                 convertNameFromArray(proccessedKey), conf)
        elif conf.getWriteClass().defaultClassTypes.has_key(str(type(v))):
            classDef.addProperty(proccessedKey, 
                                 getClassNameFromWriter(type(v), conf))
        else:
            raise Exception("Class type '%s' not supported by language '%s'" % (str(type(v)), conf.lang))
    return objColl
Exemplo n.º 7
0
    def _strip_comments(self, json):
        """
        Recursively strip comments out of loaded JSON files.

        The delimiter used to define a comment is defined in a global variable (JSON_COMMENT).

        Args:
            json: JSON content to strip comments from

        Returns:
            JSON content with comments removed

        """
        if type(json) in [str, unicode, int, float, bool, type(None)]:
            return json
        if isinstance(json, list):
            return [
                self._strip_comments(j) for j in json
                if not ((type(j) in [str, unicode])
                        and j.startswith(DelegateTools.JSON_COMMENT))
            ]
        if isinstance(json, dict):
            return dict((k, self._strip_comments(v))
                        for (k, v) in json.iteritems()
                        if k != DelegateTools.JSON_COMMENT
                        )  # there would be a dict comprehension from 2.7
Exemplo n.º 8
0
def json_to_table_data(internal_format, format_name, prefix, json):

    table_data = ""

    parsed = {
        "space": "        ",
        "internalFormat": internal_format,
        "formatName": format_name,
        "texFormat": "DXGI_FORMAT_UNKNOWN",
        "srvFormat": "DXGI_FORMAT_UNKNOWN",
        "uavFormat": "DXGI_FORMAT_UNKNOWN",
        "rtvFormat": "DXGI_FORMAT_UNKNOWN",
        "dsvFormat": "DXGI_FORMAT_UNKNOWN",
        "condition": prefix,
    }

    for k, v in json.iteritems():
        parsed[k] = v

    # Derived values.
    parsed["blitSRVFormat"] = get_blit_srv_format(parsed)
    parsed["swizzleFormat"] = get_swizzle_format_id(internal_format, parsed)
    parsed["initializer"] = angle_format.get_internal_format_initializer(
        internal_format, parsed["formatName"])

    if len(prefix) > 0:
        return split_format_entry_template.format(**parsed)
    else:
        return format_entry_template.format(**parsed)
Exemplo n.º 9
0
 def load_node_rec(self, node, json):
     for k, v in json.iteritems():
         if isinstance(v, dict):
             child = Node(k)
             node.children.append(child)
             self.load_node_rec(child, v)
         else:
             node.children.append(PropertyNode(k, v))
Exemplo n.º 10
0
def to_object(json):
    if isinstance(json, dict):
        obj = _dict_to_object({k : to_object(v) for (k,v) in json.iteritems()})
    elif isinstance(json, list):
        obj = [to_object(e) for e in json]
    else:
        obj = json
    return obj
Exemplo n.º 11
0
 def load_node_rec(self, node, json):
     for k, v in json.iteritems():
         if isinstance(v, dict):
             child = Node(k)
             node.children.append(child)
             self.load_node_rec(child, v)
         else:
             node.children.append(PropertyNode(k, v))
Exemplo n.º 12
0
def to_object(json):
    if isinstance(json, dict):
        obj = _dict_to_object({k: to_object(v) for (k, v) in json.iteritems()})
    elif isinstance(json, list):
        obj = [to_object(e) for e in json]
    else:
        obj = json
    return obj
Exemplo n.º 13
0
def create_song_map():
    json = read_json(SBD_ITEMS)
    tracks = {s: get_tracks(i) for s, i in json.iteritems()}
    metadata = {s: i['metadata'] for s, i in json.iteritems()}
    song_map = {}
    for recording, ts in tracks.iteritems():
        for track in ts:
            if 'title' in track:
                if track['title'] not in song_map:
                    song_map[track['title']] = []
                version = {}
                version['recording'] = recording
                version['track'] = track['name']
                version['year'] = metadata[recording]['year']
                if isinstance(version['year'], list):
                    version['year'] = version['year'][0]
                song_map[track['title']].append(version)
    write_json(song_map, SONG_MAP)
Exemplo n.º 14
0
 def decode_entry(self, json):
     e = TableEntry()
     for (k, v) in json.iteritems():
         if k == "match":
             e.match = self.decode_match(v)
         elif k == "actions":
             e.actions = [self.decode_action(a) for a in v]
         else:
             setattr(e, k, v)
     return e
Exemplo n.º 15
0
def dirStructureToList( jsonFile ):
	fileList = []
	json = File2Json( jsonFile )
	for topdir, sub in json.iteritems():
		for L in sub:
			if type(L) == type({}):
				for subdir, list in L.iteritems():
					for file in list:
						fileList.append( str(topdir)+str(subdir)+str(file) )
	return fileList
Exemplo n.º 16
0
def guessTypenameForDict(json):
    info = {}
    for key, value in json.iteritems():
        if type(value) == dict:
            info[key] = guessTypenameForDict(value)
        elif type(value) == list:
            info[key] = guessTypenameForArray(value)
        else:
            info[key] = set([guessTypename(value)])
    return info
Exemplo n.º 17
0
 def decode_entry(self, json):
   e = TableEntry()
   for (k, v) in json.iteritems():
     if k == "match":
       e.match = self.decode_match(v)
     elif k == "actions":
       e.actions = [ self.decode_action(a) for a in v ]
     else:
       setattr(e, k, v)
   return e
Exemplo n.º 18
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in angle_format.kChannels:
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(
        parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    sum_of_bits = 0
    for channel in angle_format.kChannels:
        sum_of_bits += int(parsed[channel])
    parsed["pixelBytes"] = sum_of_bits / 8
    parsed["componentAlignmentMask"] = get_component_alignment_mask(
        parsed["channels"], parsed["bits"])
    parsed["isBlock"] = "true" if format_id.endswith("_BLOCK") else "false"
    parsed["isFixed"] = "true" if "FIXED" in format_id else "false"

    return format_entry_template.format(**parsed)
Exemplo n.º 19
0
 def to_xml(json):
     ####### Desired
     #if len(json) == 0:
     #    return etree.Element(_internal_json_envelope_tag)
     ####### Current
     #######
     if isinstance(json, list) or len(json) > 1:
         json = {_internal_json_envelope_tag: json}
     _, value = next(json.iteritems())
     if isinstance(value, list):
         json = {_internal_json_envelope_tag: json}
     return etree.fromstring(xmltodict.unparse(json).encode('utf-8'))
Exemplo n.º 20
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in angle_format.kChannels:
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    sum_of_bits = 0
    for channel in angle_format.kChannels:
        sum_of_bits += int(parsed[channel])
    parsed["pixelBytes"] = sum_of_bits / 8
    parsed["componentAlignmentMask"] = get_component_alignment_mask(
        parsed["channels"], parsed["bits"])
    parsed["isBlock"] = "true" if format_id.endswith("_BLOCK") else "false"
    parsed["isFixed"] = "true" if "FIXED" in format_id else "false"

    return format_entry_template.format(**parsed)
Exemplo n.º 21
0
 def to_json(xml):
     json = xmltodict.parse(etree.tostring(xml),
                            expat=expat,
                            force_list=_should_force_list)
     if len(json) == 1 and isinstance(json, dict):
         key, value = next(json.iteritems())
         if key in _internal_envelope_tags:
             ####### Desired
             #json = {} if value is None else value
             ####### Current
             json = value
             #######
     return json
Exemplo n.º 22
0
def format_body(json):
    try:
        param_list = []

        for k, v in json.iteritems():
            param_dict = {"name": k, "value": v}
            param_list.append(param_dict)

        body = {"Submit": "Build", "json": {"parameter": param_list}}
        logging.debug(body)
        return urllib.urlencode(body)
    except Exception, e:
        logging.error(e)
Exemplo n.º 23
0
def fetch_xmls():
    main_xml = urllib2.urlopen(URL_CARTO, timeout=10).read()
    json = _parse_main_xml(main_xml)

    for k, v in json.iteritems():
        sta_xml_data = urllib2.urlopen(URL_STATION % k, timeout=10).read()
        sta_dict = _parse_station_xml(sta_xml_data)
        v["station"] = sta_dict
        v["station_valid"] = not int(sta_dict["total"]) == 0

    now = datetime.datetime.now()
    resp = {"markers": json, "updated": time.mktime(now.timetuple())}
    return now, resp
Exemplo n.º 24
0
def _json_to_cfg(json):
    config = ConfigParser.RawConfigParser()
    config.optionxform = str
    for section, data in json.iteritems():
        if section != ConfigParser.DEFAULTSECT:
            config.add_section(section)
        for key, value in data.iteritems():
            config.set(section, key, value)
    output = StringIO.StringIO()
    config.write(output)
    result = output.getvalue()
    output.close()
    return result
Exemplo n.º 25
0
def fetch_xmls():
    main_xml = urllib2.urlopen(URL_CARTO, timeout=10).read()
    json = _parse_main_xml(main_xml)

    for k, v in json.iteritems():
        sta_xml_data = urllib2.urlopen(URL_STATION % k, timeout=10).read()
        sta_dict = _parse_station_xml(sta_xml_data)
        v['station'] = sta_dict
        v['station_valid'] = not int(sta_dict['total']) == 0

    now = datetime.datetime.now()
    resp = {'markers': json, 'updated': time.mktime(now.timetuple())}
    return now, resp
Exemplo n.º 26
0
def showPage(show):       
    json = getJson(apiUrl + "?seasons=" + show)   
    if ("Stagione" in str(json.items()[0][0])):        
        for seasonname, seasonlink in sorted(json.iteritems()):
            addDirectoryItem(seasonname, {"action" : "season", "link": seasonlink})     
    else:
        for episode in sorted(json):
            title = episode
            eplink = json[episode][0]
            img = json[episode][1]      
            desc = json[episode][2] 
            duration = json[episode][3]
            addDirectoryItem(title, {"action" : "episode", "link": eplink}, img, False, desc, duration)
    xbmcplugin.endOfDirectory(thisPlugin)
Exemplo n.º 27
0
 def from_json(cls, json, selfObj=None):
     if selfObj is None:
         self = cls()
     else:
         self = selfObj
     exclude = (cls.__exclude__ or ()) + Serializable.__exclude__
     include = cls.__include__ or ()
     if json:
         for prop, value in json.iteritems():
             # ignore all non user data, e.g. only
             if (not (prop in exclude) | (prop in include)) and isinstance(
                     getattr(cls, prop, None), QueryableAttribute):
                 setattr(self, prop, value)
     return self
Exemplo n.º 28
0
def compress(json):
    """ Translate lumis to lumiranges e.g. [1, 2, 3, 5, 6] -> [[1,3],[5,6]]"""
    cjson = {}
    for run, lumis in json.iteritems():
        slumis = sorted(lumis)
        ranges = []
        start = slumis[0]
        for a, b in zip(slumis, slumis[1:]):
            if b != a+1 and b != a:
                ranges.append([start, a])
                start = b
        ranges.append([start, b])
        cjson[run] = ranges
    return cjson
 def probe(self):
     json = self.get_json()
     for k, v in json.iteritems():
       if k == 'status':
            yield nagiosplugin.Metric(k, v)
       elif k == 'number_of_nodes':
           yield nagiosplugin.Metric(k, v, context='nodes')
       elif k == 'number_of_data_nodes':
           yield nagiosplugin.Metric(k, v, context='data_nodes')
       elif k in ['active_primary_shards', 'active_shards', 'relocating_shards', 'initializing_shards', 'unassigned_shards', 'delayed_unassigned_shards', 'number_of_pending_tasks', 'number_of_in_flight_fetch']:
           yield nagiosplugin.Metric(k, v, context='default')
       elif k in ['task_max_waiting_in_queue_millis']:
           yield nagiosplugin.Metric(k, v, uom='ms', context='default')
       elif k in ['active_shards_percent_as_number']:
           yield nagiosplugin.Metric(k, v, uom='%', context='default')
Exemplo n.º 30
0
    def _cleanup_json(cls, json):
        for k, v in json.iteritems():
            try:
                v = int(v)
            except (ValueError, TypeError):
                pass

            if k.startswith('time_') or k in ['since']:
                v = datetime.fromtimestamp(v) if v else None
            if isinstance(v, dict):
                v = cls._cleanup_json(v)

            json[k] = v

        return json
Exemplo n.º 31
0
	def print_json(json):
		print "0) " + str(json) + " - " + type(json).__name__
		for key, val in json.iteritems():
			print "1) " + key + " - " + str(val) + " - " + type(val).__name__

			# list
			if type(val).__name__ in ('list'):
				for subkey in val:
					print "2) " + str(subkey) + " - " + type(subkey).__name__
					if type(subkey).__name__ in ('dict'):
						print_json(subkey)
			# tuple
			elif type(val).__name__ in ('tuple'):
				print_json(val)
		return
Exemplo n.º 32
0
	def search_key_in_json(self, json, searchkey):
		for key, val in json.iteritems():
			#print "1) " + str(key) + " - " + str(val)
			if searchkey == key:
				print searchkey + ":" + val
				return val

			# list
			if type(val).__name__ in ('list', 'dict'):
				for item in val:
					if searchkey == item:
						print searchkey + ":" + val
						return val
					else:
						if type(item).__name__ in ('dict', 'list'):
							return self.search_key_in_json(item, searchkey)
Exemplo n.º 33
0
    def _parseJSONForAPI(self, json):
        """
        Formats the JSON to be in a more usable syntax, collecting by date.
        """

        cleanJSON = {}

        for hitType, records in json.iteritems():
            for date, hits in records.iteritems():

                if date not in cleanJSON:
                    cleanJSON[date] = {}

                cleanJSON[date][hitType] = int(hits)

        return cleanJSON
Exemplo n.º 34
0
def fetch_xmls():
	main_xml = urlopen(URL_CARTO, timeout=10).read()
	json = _parse_main_xml(main_xml)
	
	for k, v in json.iteritems():
		sta_xml_data = urlopen(URL_STATION % k, timeout=10).read()
		sta_dict = _parse_station_xml(sta_xml_data)
		v['station'] = sta_dict
		v['station_valid'] = not int(sta_dict['total']) == 0
	
	now = datetime.datetime.now()
	resp = {
		'markers': json,
		'updated': time.mktime(now.timetuple())
		}
	return now, resp
Exemplo n.º 35
0
    def _parseJSONForAPI(self, json):
        """
        Formats the JSON to be in a more usable syntax, collecting by date.
        """

        cleanJSON = {}

        for hitType, records in json.iteritems():
            for date, hits in records.iteritems():

                if date not in cleanJSON:
                    cleanJSON[date] = {}

                cleanJSON[date][hitType] = int(hits)

        return cleanJSON
Exemplo n.º 36
0
def format_body(json):
    try: 
        param_list = []

        for k,v in json.iteritems():
            param_dict = {"name":k,
                          "value":v}
            param_list.append(param_dict)  
             
        body = {"Submit":"Build",
                "json":{
                        "parameter":param_list}
                }
        logging.debug(body)
        return urllib.urlencode(body)
    except Exception, e:
        logging.error(e)
Exemplo n.º 37
0
 def to_xwwwform(json):
     tostring = _InternalXWWWFORMJSONConverter._tostring
     tuplify = _InternalXWWWFORMJSONConverter._tuplify
     if isinstance(json, (dict, OrderedDict)):
         return _XWWWFormList([{
             tostring(key): tuplify(value)
         } for key, value in json.iteritems()])
     try:
         return _XWWWFormList(
             [{
                 tostring(key): tuplify(value)
             } for key, value in
              _InternalXWWWFORMJSONConverter._try_treat_as_xwwform(json)])
     except (TypeError, AttributeError) as e:
         return _XWWWFormList([{
             _internal_json_envelope_tag: tuplify(json)
         }])
Exemplo n.º 38
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in "ABDGLRS":
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(
        parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    return format_entry_template.format(**parsed)
Exemplo n.º 39
0
 def load_json(self, json, cas_value):
     for key, val in json.iteritems():
         if key in self._meta['_fields']:
             try:
                 origvalue = self._last_json_value[key]
             except KeyError:
                 if key in self._modified and \
                         self._meta['_fields'][key].to_json(
                         getattr(self, key)) != val:
                     raise Document.DataCollisionError(
                         "It's _modified and not equal to current val")
                 setattr(self, key, self._meta['_fields'][key].from_json(
                         self, val))
                 try:
                     del self._modified[key]
                 except KeyError:
                     pass
                 self._last_json_value[key] = \
                     self._meta['_fields'][key].to_json(getattr(self, key))
             else:
                 from_json_val = self._meta['_fields'][key].from_json(
                     self, val)
                 if from_json_val == getattr(self, key):
                     continue
                 currentvalue = self._meta['_fields'][key].to_json(
                     getattr(self, key))
                 if not self._meta['_fields'][key].have_values_changed(
                         origvalue, val) or\
                         not self._meta['_fields'][key].have_values_changed(
                         currentvalue, val):
                     continue
                 if not self._meta['_fields'][key].have_values_changed(
                         currentvalue, origvalue):
                     setattr(self, key, self._meta['_fields'][key].from_json(
                         self, val))
                     self._last_json_value[key] =\
                         self._meta['_fields'][key].to_json(
                             getattr(self, key))
                     continue
                 if val == origvalue or val == currentvalue:
                     continue
                 raise self.DataCollisionError()
     self._cas_value = cas_value
     return self
Exemplo n.º 40
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in "ABDGLRS":
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    return format_entry_template.format(**parsed)
Exemplo n.º 41
0
def count_duplicates_within_source(json):
    unique = set()
    new_map = dict()
    source = json['source']
    json.pop('source')
    for k, v in json.iteritems():
        new_map[k] = dict()
        for string in v:
            if string not in unique:
                unique.add(string)
                new_map[k].update({string:
                    {
                        'source': source,
                        'count': 1
                    }
                })
            else:
                new_map[k][string]['count'] += 1
    return new_map
Exemplo n.º 42
0
    def _strip_comments(self, json):
        """
        Recursively strip comments out of loaded JSON files.

        The delimiter used to define a comment is defined in a global variable (JSON_COMMENT).

        Args:
            json: JSON content to strip comments from

        Returns:
            JSON content with comments removed

        """
        if type(json) in [str, unicode, int, float, bool, type(None)]:
            return json
        if isinstance(json, list):
            return [self._strip_comments(j) for j in json if not ((type(j) in [str, unicode]) and j.startswith(DelegateTools.JSON_COMMENT))]
        if isinstance(json, dict):
            return dict( (k, self._strip_comments(v)) for (k,v) in json.iteritems() if k != DelegateTools.JSON_COMMENT) # there would be a dict comprehension from 2.7
Exemplo n.º 43
0
def json2yaml(json, level=0):
    spaces = "  "
    new_line = "\n"
    to_print = ""
    for key, value in json.iteritems():

        to_print += (spaces * level) + key + ":"
        vType = type(value)

        if vType is dict:
            to_print += "\n" + json2yaml(value, level + 1)
        elif vType is list:
            for item in value:
                to_print += new_line + (spaces * level + spaces) + "- " + item
            to_print += new_line
        else:
            to_print += " " + value + new_line

    return to_print
Exemplo n.º 44
0
Arquivo: jgd2.py Projeto: H1ghT0p/jgd
    def __json_load_helper(self, json):
        if "id" in json:
            node = self.add_node(unicode(json["id"]))
        else:
            node = self.add_node(self.__generate_id())

        for k, v in json.iteritems():
            t = self.ns_split_id(k)
            if t is not None:
                ns, pred = t
                if pred == "id":
                    #only IDs for now
                    if self.ns.get(ns) is None:
                        self.add_ns_adapter(ns, NullAdapter)
                    self.__add_ns_id_for_node(ns, v, self.ids[node])
            else:
                if type(v) == type([]):
                    for target in v:
                        if type(target) == type({}):
                            t = self.__json_load_helper(target)
                            self.add_link((node, k, t))
                        elif type(target) == type([]):
                            raise JSONLoadException()
                        else:
                            if target.startswith(":"):
                                target = self.add_node(target)
                            self.add_link((node, k, target))
                elif type(v) == type({}):
                    t = self.__json_load_helper(v)
                    self.add_link((node, k, t))
                elif v is None:
                    continue
                elif type(v) == type(3):
                    self.add_link((node, k, unicode(v)))
                else:
                    if k == "id":
                        continue
                    if v.startswith(":"):
                        v = self.add_node(v)
                    self.add_link((node, k, v))

        return node
Exemplo n.º 45
0
    def _parseJSONForAPI(self, json, excludeEmptyDates=False):
        """
        Returns a simpler dictionary containing form:
        {'date' : {'total_hits': x, 'unique_hits': y}}
        """
        cleanJSON = {}

        for date, hits in json.iteritems():
            dayHits = {self._strTotalHits: 0, self._strUniqueHits: 0}

            if hits:  # Piwik returns hits as a list of dictionaries, per date.
                for metrics in hits:
                    dayHits[self._strTotalHits] += metrics[self._totalHitMetric]
                    dayHits[self._strUniqueHits] += metrics[self._totalUniqueHits]

            elif excludeEmptyDates:
                continue

            cleanJSON[date] = dayHits

        return cleanJSON
Exemplo n.º 46
0
def write_json_key_values(file, json, prefix = 'EB_CONFIG'):
  for key, value in json.iteritems():
    key = re.sub('\\W', '_', key)
    if prefix == 'EB_CONFIG_PLUGINS_RDS_ENV' or \
        prefix == 'EB_CONFIG_ENV' or prefix == 'EB_CONFIG_PHP_ENV':
      prefix = None
    elif prefix is not None:
      key = key.upper()
    if isinstance(value, dict):
      write_json_key_values(file, value, '_'.join((prefix, key)))
    elif key == 'ENV' and isinstance(value, list):
      for val in value:
        file.write('export %s\n' % (val))
    else:
      if value is None:
        value = ''
      value = str(value).encode("string_escape")
      if prefix is None:
        pdata = ''
      else:
        pdata = prefix + '_'
      file.write('export %s%s="%s"\n' % (pdata, key, value))
Exemplo n.º 47
0
def resolve_ref(json, base=None):
    """return a json with resolved internal references

    only support local reference to the same json
    """
    if not base :
        base = json

    temp = None
    if type(json) is list:
        temp = [];
        for item in json:
            temp.append(resolve_ref(item, base=base))
    elif type(json) is dict:
        temp = {};
        for key,value in json.iteritems():
            if key == '$ref':
                return resolve_ref(jsonpointer.resolve_pointer(base,value), base=base)
            else :
                temp[key]=resolve_ref(value, base=base)
    else :
        return json
    return temp
Exemplo n.º 48
0
def json_to_series(json, field, func):
    results = [(int(t), aggregate_vals(r, field, func))
               for t, r in json.iteritems()]
    results.sort(key=lambda r: r[0])
    tracks, values = zip(*results)
    return pd.Series(values, index=tracks)
Exemplo n.º 49
0
 def __build_message(self, json):
     message_lines = []
     for header, value in json.iteritems():
         message_lines.append("%s: %s" % (header, value))
     return mimetools.Message(StringIO("\n".join(message_lines)))
Exemplo n.º 50
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in angle_format.kChannels:
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(
        parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    is_block = format_id.endswith("_BLOCK")

    pixel_bytes = 0
    if is_block:
        assert 'blockPixelBytes' in parsed, \
            'Compressed format %s requires its block size to be specified in angle_format_data.json' % \
                format_id
        pixel_bytes = parsed['blockPixelBytes']
    else:
        sum_of_bits = 0
        for channel in angle_format.kChannels:
            sum_of_bits += int(parsed[channel])
        pixel_bytes = ceil_int(sum_of_bits, 8)
    parsed["pixelBytes"] = pixel_bytes
    parsed["componentAlignmentMask"] = get_component_alignment_mask(
        parsed["channels"], parsed["bits"])
    parsed["isBlock"] = bool_str(is_block)
    parsed["isFixed"] = bool_str("FIXED" in format_id)
    parsed["isScaled"] = bool_str("SCALED" in format_id)
    parsed["isSRGB"] = bool_str("SRGB" in format_id)
    # For now we only look for the 'PLANE' substring in format string. Expand this condition
    # when adding support for YUV formats that have different identifying markers.
    parsed["isYUV"] = bool_str("PLANE" in format_id)

    parsed[
        "vertexAttribType"] = "gl::VertexAttribType::" + get_vertex_attrib_type(
            format_id)

    return format_entry_template.format(**parsed)
Exemplo n.º 51
0
            filelist.append(line.strip())
        print "    > found ", len(filelist), " files in the run range"

    ################### mask the JSON (if any provided) by the run range
    skimmedJSON = {}
    if args.jsonFile:
        print "... using JSON file: ", args.jsonFile
        try:
            json = eval(open(args.jsonFile).read())
        except:
            print "** Error: json", args.jsonFile, "not a valid JSON"
            sys.exit()
        print "    > doing intersection with run range ", args.runrange[
            0], args.runrange[1]
        skimmedJSON = dict([
            (key, value) for key, value in json.iteritems()
            if key >= args.runrange[0] and key <= args.runrange[1]
        ])
        # print skimmedJSON
        if len(skimmedJSON) == 0:
            print "** Error: json ", args.jsonFile, " has no intersection with run range", args.runrange[
                0], args.runrange[1]
            sys.exit()

    ################### prepare input to each job passing as command line parameters
    # save JSON as txt
    if args.jsonFile:
        jsonName = args.tag + "/json_" + args.runrange[
            0] + "_" + args.runrange[1] + ".txt"
        fJSON = open(jsonName, 'w')
        fJSON.write('{')
Exemplo n.º 52
0
def json_to_table_data(format_id, json, angle_to_gl):

    table_data = ""

    parsed = {
        "id": format_id,
        "fastCopyFunctions": "NoCopyFunctions",
    }

    for k, v in json.iteritems():
        parsed[k] = v

    if "glInternalFormat" not in parsed:
        parsed["glInternalFormat"] = angle_to_gl[format_id]

    if "fboImplementationInternalFormat" not in parsed:
        parsed["fboImplementationInternalFormat"] = parsed["glInternalFormat"]

    if "componentType" not in parsed:
        parsed["componentType"] = angle_format.get_component_type(format_id)

    if "channels" not in parsed:
        parsed["channels"] = angle_format.get_channels(format_id)

    if "bits" not in parsed:
        parsed["bits"] = angle_format.get_bits(format_id)

    # Derived values.
    parsed["mipGenerationFunction"] = get_mip_generation_function(parsed)
    parsed["colorReadFunction"] = get_color_read_function(parsed)
    parsed["colorWriteFunction"] = get_color_write_function(parsed)

    for channel in angle_format.kChannels:
        if parsed["bits"] != None and channel in parsed["bits"]:
            parsed[channel] = parsed["bits"][channel]
        else:
            parsed[channel] = "0"

    parsed["namedComponentType"] = get_named_component_type(
        parsed["componentType"])

    if format_id == "B8G8R8A8_UNORM":
        parsed["fastCopyFunctions"] = "BGRACopyFunctions"

    is_block = format_id.endswith("_BLOCK")

    pixel_bytes = 0
    if is_block:
        assert 'blockPixelBytes' in parsed, \
            'Compressed format %s requires its block size to be specified in angle_format_data.json' % \
                format_id
        pixel_bytes = parsed['blockPixelBytes']
    else:
        sum_of_bits = 0
        for channel in angle_format.kChannels:
            sum_of_bits += int(parsed[channel])
        pixel_bytes = sum_of_bits / 8
    parsed["pixelBytes"] = pixel_bytes
    parsed["componentAlignmentMask"] = get_component_alignment_mask(
        parsed["channels"], parsed["bits"])
    parsed["isBlock"] = "true" if is_block else "false"
    parsed["isFixed"] = "true" if "FIXED" in format_id else "false"
    parsed["isScaled"] = "true" if "SCALED" in format_id else "false"

    parsed[
        "vertexAttribType"] = "gl::VertexAttribType::" + get_vertex_attrib_type(
            format_id)

    return format_entry_template.format(**parsed)
    def get_timestamps(self, json, itemname):

        global ts
        global newjson

        if type(json) == unicode:
            return json

        elif type(json) == list:
            return json

        else:

            for key, value in json.iteritems():

                if "Item" in key:

                    name = key.replace('Item', '')
                    version = name + "Versions"

                    for versions in value[version]:

                        data = versions["data"]
                        ts = versions["timestamp"]

                        newjson = {}
                        newjson.update({"data": {itemname: {}}})
                        newjson.update({"timestamp": ts})
                        if newjson not in jsonArray:
                            jsonArray.append(newjson)

                else:

                    if type(value) == unicode:
                        s = self.get_timestamps(value, itemname)

                    elif type(value) == list:

                        s = self.get_timestamps(value, itemname)

                        for i in range(0, len(s)):

                            if type(s[i]) != unicode:
                                for k, v in s[i].iteritems():

                                    if k == "timestamp":
                                        newjson = {}
                                        newjson.update(
                                            {"data": {
                                                itemname: {}
                                            }})
                                        newjson.update({"timestamp": v})

                                        if newjson not in jsonArray:
                                            jsonArray.append(newjson)

                    elif type(value) == dict:
                        for k, v in value.iteritems():
                            s = self.get_timestamps(v, itemname)

        return jsonArray
Exemplo n.º 54
0
import json, sys
from pprint import pprint

if len(sys.argv) != 2 :
    print sys.argv[0], "running with arglist:", str(sys.argv), \
        "\ncorrect syntax :", sys.argv[0], "INPUT_JSON_FILE"
    sys.exit(100)

fileData=open(sys.argv[1]).read()
json = json.loads(fileData)

tCutString = ""

isFirstRun = True
for run, lumiRanges in json.iteritems() :
    if not isFirstRun :
        tCutString += " || "
    isFirstRun = False
    tCutString += "( run==" + str(run)  + " && ( " 

    isFirstRange = True
    for lumiRange in lumiRanges :
        if not isFirstRange :
            tCutString += " || "
        isFirstRange = False

        tCutString += "( lumi>=" + str(lumiRange[0])  + " && lumi<=" + str(lumiRange[1]) + ")"

    tCutString += " ) ) "
Exemplo n.º 55
0
def showLetter(letter):       
    json = getJson(apiUrl + "?letter=" + letter)
    for showname, showlink in sorted(json.iteritems()):
        addDirectoryItem(showname, {"action" : "show", "link": showlink})     
    xbmcplugin.endOfDirectory(thisPlugin)