:param start: start key in dot notation
        returns the dict in json format
        :return: json string version
        :rtype: string
511196
def json(self, start=None):
        
        if start is not None:
            data = self.data[start]
        return json.dumps(self.data, indent=4)
1010052
def to_json(self):
    
    return {self.NAMESPACE_RANGE_PARAM: self.ns_range.to_json_object(),
            self.BATCH_SIZE_PARAM: self._batch_size}
781380
def to_json(self):
        
        return {
            'resourceType': self.resource.resource_type_id,
            'resourceId': self.id,
            'accountId': self.resource.account_id,
            'account': self.account,
            'location': self.resource.location,
            'properties': {to_camelcase(prop.name): prop.value for prop in self.resource.properties},
            'tags': [{'key': t.key, 'value': t.value} for t in self.resource.tags]
        }
776339
def to_json(self):
        

        result = super(Environment, self).to_json()
        result.update({
            'name': self.name
        })

        return result
956002
def serialize(self):
        
        return {"hstart": self.hstart, "mstart": self.mstart,
                "hend": self.hend, "mend": self.mend,
                "is_valid": self.is_valid}
86511
def start(self, **kwargs):
        
        return self.client.api.start(self.id, **kwargs)
1161698
def _collection_json_response(cls, resources, start, stop, depth=0):
    

    top_level_json_name = None
    if cls.__top_level_json_name__ is not None:
        top_level_json_name = cls.__top_level_json_name__
    else:
        top_level_json_name = 'resources'

    result_list = []
    for resource in resources:
        result_list.append(resource.as_dict(depth))

    payload = {}
    if start is not None:
        payload[top_level_json_name] = result_list[start:stop]
    else:
        payload[top_level_json_name] = result_list

    return jsonify(payload)
81437
def ToJson(self, index):
        
        return {
            'n': index,
            'asset': self.AssetId.To0xString(),
            'value': self.Value.ToNeoJsonString(),
            'address': self.Address
        }
1009465
def to_json(self):
    
    return {
        "build_number": self._build_number,
        "commit_hash": self._commit_hash,
        "last_modified": self._last_modified,
        "location": self._location,
        "modified_by": self._modified_by,
        "status": self._status,
        "value": self._value,
        "version_id": self._version_id
    }
889342
def to_json(self):
        
        json_dict = {'keyboard': self.keyboard}
        if self.one_time_keyboard:
            json_dict['one_time_keyboard'] = True

        if self.resize_keyboard:
            json_dict['resize_keyboard'] = True

        if self.selective:
            json_dict['selective'] = True

        return json.dumps(json_dict)
824702
def json(self, dict=None, indent=None):
        
        if not dict:
            dict = self.dict()
        for key, value in dict.iteritems():
            if type(value) == datetime.datetime:
                dict[key] = value.strftime(conf.GOSCALE_ATOM_DATETIME_FORMAT)
        return simplejson.dumps(dict, indent=indent)
1315836
def to_json(self, *, include_keys=None, exclude_keys=None, use_default_excludes=True,
              pretty=False):
    
    return to_json(
      self.to_dict(
        include_keys=include_keys,
        exclude_keys=exclude_keys,
        use_default_excludes=use_default_excludes),
      pretty=pretty)
628602
def jsonarrindex(self, name, path, scalar, start=0, stop=-1):
        
        return self.execute_command('JSON.ARRINDEX', name, str_path(path), self._encode(scalar), start, stop)
739686
def make_dict(self):
        
        out = {}
        while True:
            try:
                key = self.dict_key()
                self.separator(separator=":")
                value = self.value_assign(end_token="]")
                out[key] = value
                self.separator(end_token="}")
            except self.ParseEnd:
                return out
625192
def init_cache():
    '''
    
    '''
    cache_obj = json.loads("{}")
    try:
        with open(CACHE_NAME, 'r') as cache_file:
            try:
                cache_obj = json.load(cache_file)
            except ValueError:
                print("The cache file seems to be empty, starting with flushed cache")
    except IOError:
        print("The cache file seems to be empty, starting with flushed cache")

    print("Loaded JSON cache")

    return cache_obj
218921
def json(self):
        
        return {
            "status": self.status,
            "criteria_name": self.criteria_name,
            "warnings": [w.json() for w in self.warnings],
            "settings": self.settings,
        }
1307879
def _update_dict(self, initial: JSON, other: Mapping) -> JSON:
        
        for key, value in other.items():
            if isinstance(value, collections.Mapping):
                r = self._update_dict(initial.get(key, {}), value)
                initial[key] = r
            else:
                initial[key] = other[key]
        return initial