use native json at least for parsing in the first place

std/python/Lib.hx

@@ -1,5 +1,6 @@
 package python;
 
+import python.lib.Dict;
 import python.NativeStringTools;
 
 typedef PySys = python.lib.Sys;
@@ -20,6 +21,23 @@ class Lib {
 		PySys.stdout.flush();
 	}
 
+	public static function dictToAnon (v:Dict<String, Dynamic>):Dynamic
+	{
+		var o = {};
+		Syntax.assign(Syntax.field(o, "__dict__"), v);
+		return o;
+	}
+
+	@:access(python.Boot) public static function anonToDict (o:{}):Dynamic
+	{
+		return if (python.Boot.isAnonObject(o))
+		{
+			Syntax.field(o, "__dict__");
+		}
+		else null;
+
+	}
+
 	public static function toPythonIterable <T>(it:Iterable<T>):python.NativeIterable<T> {
 		return {
 			__iter__ : function () {

std/python/_std/haxe/Json.hx

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C)2005-2012 Haxe Foundation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+package haxe;
+
+import python.Syntax;
+
+/**
+	Crossplatform JSON API : it will automatically use the optimized native API if available.
+	Use -D haxeJSON to force usage of the Haxe implementation even if a native API is found : this will provide
+	extra encoding features such as enums (replaced by their index) and StringMaps.
+**/
+class Json {
+
+	/**
+		Parses given JSON-encoded `text` and returns the resulting object.
+
+		JSON objects are parsed into anonymous structures and JSON arrays
+		are parsed into Array<Dynamic>.
+
+		If given `text` is not valid JSON, an exception will be thrown.
+	**/
+	public static inline function parse( text : String ) : Dynamic {
+		return python.lib.Json.loads(text, null, null, python.Lib.dictToAnon);
+	}
+
+	/**
+		Encodes given `value` and returns the resulting JSON string.
+
+		If `replacer` is given and is not null, it is used to retrieve
+		actual object to be encoded. The `replacer` function two parameters,
+		the key and the value being encoded. Initial key value is an empty string.
+
+		If `space` is given and is not null, the result will be pretty-printed.
+		Successive levels will be indented by this string.
+	**/
+	public static inline function stringify( value : Dynamic, ?replacer:Dynamic -> Dynamic -> Dynamic, ?space : String ) : String {
+
+		return haxe.format.JsonPrinter.print(value, replacer, space);
+		/*
+		function def (o:Dynamic) {
+			trace(o);
+			return python.Lib.anonToDict(o);
+		}
+		return python.lib.Json.dumps(value, false, false, true, true, null, null, null, def);
+		*/
+
+	}
+
+}

std/python/lib/Json.hx

@@ -1,12 +1,23 @@
 
 package python.lib;
 
+import python.KwArgs;
 import python.lib.Dict;
+import python.lib.Tuple.Tup2;
 
 extern class Json {
 
 
-	public static function loads (s:String):Dict<String, Dynamic>;
+	public static function loads (
+		s:String,
+		encoding:Null<String> = null,
+		cls : Null<Dynamic> = null,
+		object_hook:Null<Dict<String, Dynamic>->Dynamic> = null
+		):Dict<String, Dynamic>;
+	public static function dumps (x:Dynamic, skipkeys:Bool=false, ensure_ascii:Bool=true, check_circular:Bool=true,
+		allow_nan:Bool=true,
+		cls:Null<Dynamic> = null, indent:Null<String> = null,
+		separators:Null<Tup2<String,String>>, /*default*/def:Null<Dynamic->String> = null, sort_keys:Bool=false, kw:KwArgs = null):String;
 
 	static function __init__ ():Void
 	{

std/python/lib/json/JSONEncoder.hx

@@ -0,0 +1,9 @@
+
+package python.lib.json;
+
+extern class JSONEncoder {
+
+	static function __init__ ():Void {
+		python.Syntax.importFromAs("json", "JSONEncoder", "python.lib.json.JSONEncoder");
+	}
+}