move some base types into python.lib

std/haxe/Resource.hx

@@ -39,7 +39,7 @@ class Resource {
 	#if (java || cs)
 	@:keep static var content : Array<String>;
 	#elseif python
-	static var content : python.lib.Types.Dict<String, BytesData>;
+	static var content : python.lib.Dict<String, BytesData>;
 	#else
 	static var content : Array<{ name : String, data : String, str : String }>;
 	#end

std/python/_std/haxe/ds/IntMap.hx

@@ -1,6 +1,6 @@
 package haxe.ds;
 
-import python.lib.Types.Dict;
+import python.lib.Dict;
 import python.Syntax;
 
 class IntMap<T> implements Map.IMap<Int, T> {

std/python/_std/haxe/ds/ObjectMap.hx

@@ -1,7 +1,7 @@
 package haxe.ds;
 
 import python.lib.Builtin;
-import python.lib.Types;
+import python.lib.Dict;
 
 class ObjectMap<K:{},V> implements Map.IMap<K, V> {
 

std/python/_std/haxe/ds/StringMap.hx

@@ -1,7 +1,8 @@
 package haxe.ds;
 
-import python.lib.Types.Dict;
+
 import python.Syntax;
+import python.lib.Dict;
 
 class StringMap<T> implements Map.IMap<String, T> {
 	private var h : Dict<String,T>;

std/python/internal/Internal.hx

@@ -51,7 +51,7 @@ class Internal {
 	}
 
 	macro public static function classRegistry ():Expr {
-		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Types.Dict<String, Class<Dynamic>>);
+		return macro (python.Syntax.pythonCode($v{_classes}) : python.lib.Dict<String, Class<Dynamic>>);
 	}
 
 	macro public static function callFieldPrefixed (o:Expr, x:String, params:Array<Expr>):Expr {

std/python/lib/Builtin.hx

@@ -4,6 +4,7 @@ package python.lib;
 
 import python.lib.io.IOBase;
 import python.lib.Types;
+import python.lib.Dict;
 
 
 

std/python/lib/Dict.hx

@@ -0,0 +1,93 @@
+
+package python.lib;
+
+import python.lib.Builtin;
+import python.lib.Tuple;
+import python.lib.Types;
+import python.Syntax;
+
+
+extern class DictView<T> {
+	public inline function iter ():PyIterator<T>
+	{
+		return Builtin.iter(this);
+	}
+	public inline function length ():Int
+	{
+		return Builtin.len(this);
+	}
+
+	public inline function iterator ():Iterator<T>
+	{
+		return iter();
+	}
+}
+
+extern class Dict <K, V>
+{
+	public function new ():Void;
+
+	public inline function length ():Int
+	{
+		return python.lib.Builtin.len(this);
+	}
+
+	public inline function hasKey (k:K):Bool {
+		return DictImpl.hasKey(this,k);
+	}
+
+	public function clear ():Void;
+	public function copy ():Dict<K,V>;
+	public function get (key:K, def:V):V;
+
+	public function update (d:Dict<K,V>):Void;
+
+	public function keys ():DictView<K>;
+	public function values ():DictView<V>;
+	public function items ():DictView<Tup2<K,V>>;
+
+	public static inline function fromObject (x:{}):Dict<String,Dynamic> {
+		return DictImpl.fromObject(x);
+	}
+	public inline function set (key:K, val:V):Void {
+		DictImpl.set(this, key, val);
+	}
+
+	public inline function remove (key:K):Void
+	{
+		DictImpl.remove(this, key);
+	}
+
+	public inline function iterator ():Iterator<V>
+	{
+		return values().iter();
+	}
+	public function __iter__():PyIterator<K>;
+
+	static function __init__ ():Void
+	{
+		Syntax.importFromAs("builtins", "dict", "python.lib.Dict");
+	}
+
+}
+
+class DictImpl {
+	public static inline function fromObject (x:{}) {
+		var d = new Dict();
+		for (f in Reflect.fields(x)) {
+			d.set(f, Reflect.field(x,f));
+		}
+		return d;
+	}
+	public static inline function hasKey <X>(d:Dict<X, Dynamic>, key:X) {
+		return Syntax.isIn(key, d);
+	}
+
+	public static inline function remove <X>(d:Dict<X, Dynamic>, key:X) {
+		Syntax.delete(python.Syntax.arrayAccess(d, key));
+	}
+
+	public static inline function set <K,V>(d:Dict<K, V>, key:K, val:V) {
+		Syntax.arraySet(d, key, val);
+	}
+}

std/python/lib/Os.hx

@@ -2,6 +2,7 @@
 package python.lib;
 
 
+import python.lib.Tuple;
 import python.lib.Types;
 
 extern class Stat {

std/python/lib/Re.hx

@@ -2,7 +2,7 @@
 package python.lib;
 
 import python.lib.Types;
-
+import python.lib.Tuple;
 
 
 typedef TODO = Dynamic;

std/python/lib/Set.hx

@@ -0,0 +1,42 @@
+
+package python.lib;
+
+import python.lib.Types.PyIterator;
+
+extern class Set <T>
+{
+	@:overload(function (?array:Array<T>):Void {})
+	public function new (?iterable:python.lib.Types.PyIterable<T>):Void;
+
+	public inline function length ():Int
+	{
+		return python.lib.Builtin.len(this);
+	}
+
+	public inline function has (v:T):Bool
+	{
+		return python.Syntax.isIn(v, this);
+	}
+
+
+	public inline function minus (other:Set<T>):Set<T>
+	{
+		return python.Syntax.binop(this, "-", other);
+	}
+	public inline function plus (other:Set<T>):Set<T>
+	{
+		return python.Syntax.binop(this, "+", other);
+	}
+
+	static function __init__ ():Void
+	{
+		Syntax.importFromAs("builtins", "set", "python.lib.Set");
+	}
+
+	function __iter__ ():PyIterator<T>;
+
+	public inline function iterator ():Iterator<T>
+	{
+		return __iter__();
+	}
+}

std/python/lib/StringTools.hx

@@ -2,7 +2,7 @@
 package python.lib;
 
 import python.lib.Types.Bytes;
-import python.lib.Types.Tup3;
+import python.lib.Tuple;
 
 class StringTools {
 

std/python/lib/Sys.hx

@@ -3,6 +3,7 @@ package python.lib;
 import python.lib.io.FileIO;
 import python.lib.io.RawIOBase;
 import python.lib.io.TextIOBase;
+import python.lib.Tuple.Tup3;
 import python.lib.Types;
 
 extern class Sys {

std/python/lib/Traceback.hx

@@ -1,6 +1,7 @@
 package python.lib;
 
 import python.lib.Types;
+import python.lib.Tuple;
 
 extern class Traceback {
 

std/python/lib/Tuple.hx

@@ -0,0 +1,81 @@
+
+package python.lib;
+
+import python.lib.Builtin;
+import python.Syntax;
+
+
+extern class Tuple<X> implements ArrayAccess<X> {
+
+	public static inline function empty<X>():Tuple<X> {
+		return Builtin.tuple();
+	}
+
+	public static inline function fromArray<X>(a:Array<X>):Tuple<X> {
+		return Builtin.tuple(a);
+	}
+
+	public var length(get_length, null):Int;
+
+	inline function get_length():Int {
+		return Builtin.len(this);
+	}
+
+	public inline function at (i:Int):X {
+		return Syntax.arrayAccess(this, i);
+	}
+
+	public inline function toArray ():Array<X>
+	{
+		return Builtin.list(this);
+	}
+
+}
+
+extern class Tup2 <A,B> extends Tuple<Dynamic>
+{
+	public static inline function create <A,B>(a:A, b:B):Tup2<A,B> return Syntax.tuple(a,b);
+	public var _1(get, null):A;
+	public inline function get__1():A return Syntax.arrayAccess(this, 0);
+	public var _2(get, null):B;
+	public inline function get__2():B return Syntax.arrayAccess(this, 1);
+}
+
+extern class Tup3 <A,B,C> extends Tuple<Dynamic>
+{
+	public static inline function create <A,B,C>(a:A, b:B,c:C):Tup3<A,B,C> return Syntax.tuple(a,b,c);
+	public var _1(get, null):A;
+	public inline function get__1():A return Syntax.arrayAccess(this, 0);
+	public var _2(get, null):B;
+	public inline function get__2():B return Syntax.arrayAccess(this, 1);
+	public var _3(get, null):C;
+	public inline function get__3():C return Syntax.arrayAccess(this, 2);
+}
+
+extern class Tup4 <A,B,C,D> extends Tuple<Dynamic>
+{
+	public static inline function create <A,B,C,D>(a:A, b:B,c:C,d:D):Tup4<A,B,C,D> return Syntax.tuple(a,b,c,d);
+	public var _1(get, null):A;
+	public inline function get__1():A return Syntax.arrayAccess(this, 0);
+	public var _2(get, null):B;
+	public inline function get__2():B return Syntax.arrayAccess(this, 1);
+	public var _3(get, null):C;
+	public inline function get__3():C return Syntax.arrayAccess(this, 2);
+	public var _4(get, null):D;
+	public inline function get__4():D return Syntax.arrayAccess(this, 3);
+}
+
+extern class Tup5 <A,B,C,D,E> extends Tuple<Dynamic>
+{
+	public static inline function create <A,B,C,D,E>(a:A, b:B,c:C,d:D,e:E):Tup5<A,B,C,D,E> return Syntax.tuple(a,b,c,d,e);
+	public var _1(get, null):A;
+	public inline function get__1():A return Syntax.arrayAccess(this, 0);
+	public var _2(get, null):B;
+	public inline function get__2():B return Syntax.arrayAccess(this, 1);
+	public var _3(get, null):C;
+	public inline function get__3():C return Syntax.arrayAccess(this, 2);
+	public var _4(get, null):D;
+	public inline function get__4():D return Syntax.arrayAccess(this, 3);
+	public var _5(get, null):E;
+	public inline function get__5():E return Syntax.arrayAccess(this, 4);
+}

std/python/lib/Types.hx

@@ -145,210 +145,11 @@ extern class FileDescriptor {
 //}
 
 //@:native("set")
-extern class Set <T>
-{
-
-	@:overload(function (?array:Array<T>):Void {})
-	public function new (?iterable:python.lib.Types.PyIterable<T>):Void;
-
-	public inline function length ():Int
-	{
-		return python.lib.Builtin.len(this);
-	}
-
-	public inline function has (v:T):Bool
-	{
-		return python.Syntax.isIn(v, this);
-	}
-
-
-	public inline function minus (other:Set<T>):Set<T>
-	{
-		return python.Syntax.binop(this, "-", other);
-	}
-	public inline function plus (other:Set<T>):Set<T>
-	{
-		return python.Syntax.binop(this, "+", other);
-	}
-
-	static function __init__ ():Void
-	{
-		Syntax.importFromAs("builtins", "set", "python.lib.Set");
-	}
-
-	function __iter__ ():PyIterator<T>;
-
-	public inline function iterator ():Iterator<T>
-	{
-		return __iter__();
-	}
-}
-
-extern class DictView<T> {
-	public inline function iter ():PyIterator<T>
-	{
-		return Builtin.iter(this);
-	}
-	public inline function length ():Int
-	{
-		return Builtin.len(this);
-	}
-
-	public inline function iterator ():Iterator<T>
-	{
-		return iter();
-	}
-}
-
-
-//@:native("dict")
-extern class Dict <K, V>
-{
-	public function new ():Void;
-
-	public inline function length ():Int
-	{
-		return python.lib.Builtin.len(this);
-	}
-
-	public inline function hasKey (k:K):Bool {
-		return DictImpl.hasKey(this,k);
-	}
-
-	public function clear ():Void;
-	public function copy ():Dict<K,V>;
-	public function get (key:K, def:V):V;
-
-	public function update (d:Dict<K,V>):Void;
-
-	public function keys ():DictView<K>;
-	public function values ():DictView<V>;
-	public function items ():DictView<Tup2<K,V>>;
-
-	public static inline function fromObject (x:{}):Dict<String,Dynamic> {
-		return DictImpl.fromObject(x);
-	}
-	public inline function set (key:K, val:V):Void {
-		DictImpl.set(this, key, val);
-	}
 
-	public inline function remove (key:K):Void
-	{
-		DictImpl.remove(this, key);
-	}
-
-	public inline function iterator ():Iterator<V>
-	{
-		return values().iter();
-	}
-	public function __iter__():PyIterator<K>;
-
-	static function __init__ ():Void
-	{
-		Syntax.importFromAs("builtins", "dict", "python.lib.Dict");
-	}
-
-}
-
-class DictImpl {
-	public static inline function fromObject (x:{}) {
-		var d = new Dict();
-		for (f in Reflect.fields(x)) {
-			d.set(f, Reflect.field(x,f));
-		}
-		return d;
-	}
-	public static inline function hasKey <X>(d:Dict<X, Dynamic>, key:X) {
-		return python.Syntax.isIn(key, d);
-	}
-
-	public static inline function remove <X>(d:Dict<X, Dynamic>, key:X) {
-		python.Syntax.delete(python.Syntax.arrayAccess(d, key));
-	}
-
-	public static inline function set <K,V>(d:Dict<K, V>, key:K, val:V) {
-		python.Syntax.arraySet(d, key, val);
-	}
-}
-
-
-
-extern class Tuple<X> implements ArrayAccess<X> {
-
-	public static inline function empty<X>():Tuple<X> {
-		return Builtin.tuple();
-	}
 
 
 
-	public static inline function fromArray<X>(a:Array<X>):Tuple<X> {
-		return Builtin.tuple(a);
-	}
-
-	public var length(get_length, null):Int;
-
-	inline function get_length():Int {
-		return Builtin.len(this);
-	}
-
-	public inline function at (i:Int):X {
-		return python.Syntax.arrayAccess(this, i);
-	}
-
-	public inline function toArray ():Array<X>
-	{
-		return Builtin.list(this);
-	}
-
-}
-
-extern class Tup2 <A,B> extends Tuple<Dynamic>
-{
-	public static inline function create <A,B>(a:A, b:B):Tup2<A,B> return python.Syntax.tuple(a,b);
-	public var _1(get, null):A;
-	public inline function get__1():A return python.Syntax.arrayAccess(this, 0);
-	public var _2(get, null):B;
-	public inline function get__2():B return python.Syntax.arrayAccess(this, 1);
-}
-
-extern class Tup3 <A,B,C> extends Tuple<Dynamic>
-{
-	public static inline function create <A,B,C>(a:A, b:B,c:C):Tup3<A,B,C> return python.Syntax.tuple(a,b,c);
-	public var _1(get, null):A;
-	public inline function get__1():A return python.Syntax.arrayAccess(this, 0);
-	public var _2(get, null):B;
-	public inline function get__2():B return python.Syntax.arrayAccess(this, 1);
-	public var _3(get, null):C;
-	public inline function get__3():C return python.Syntax.arrayAccess(this, 2);
-}
-
-extern class Tup4 <A,B,C,D> extends Tuple<Dynamic>
-{
-	public static inline function create <A,B,C,D>(a:A, b:B,c:C,d:D):Tup4<A,B,C,D> return python.Syntax.tuple(a,b,c,d);
-	public var _1(get, null):A;
-	public inline function get__1():A return python.Syntax.arrayAccess(this, 0);
-	public var _2(get, null):B;
-	public inline function get__2():B return python.Syntax.arrayAccess(this, 1);
-	public var _3(get, null):C;
-	public inline function get__3():C return python.Syntax.arrayAccess(this, 2);
-	public var _4(get, null):D;
-	public inline function get__4():D return python.Syntax.arrayAccess(this, 3);
-}
 
-extern class Tup5 <A,B,C,D,E> extends Tuple<Dynamic>
-{
-	public static inline function create <A,B,C,D,E>(a:A, b:B,c:C,d:D,e:E):Tup5<A,B,C,D,E> return python.Syntax.tuple(a,b,c,d,e);
-	public var _1(get, null):A;
-	public inline function get__1():A return python.Syntax.arrayAccess(this, 0);
-	public var _2(get, null):B;
-	public inline function get__2():B return python.Syntax.arrayAccess(this, 1);
-	public var _3(get, null):C;
-	public inline function get__3():C return python.Syntax.arrayAccess(this, 2);
-	public var _4(get, null):D;
-	public inline function get__4():D return python.Syntax.arrayAccess(this, 3);
-	public var _5(get, null):E;
-	public inline function get__5():E return python.Syntax.arrayAccess(this, 4);
-}
 
 
 @:native("BaseException")

std/python/lib/os/Path.hx

@@ -2,6 +2,7 @@
 package python.lib.os;
 
 import python.lib.Types;
+import python.lib.Tuple;
 
 extern class Path {
 

std/python/lib/subprocess/Popen.hx

@@ -5,6 +5,7 @@ import python.lib.io.BufferedReader;
 import python.lib.io.TextIOBase;
 import python.lib.Subprocess.StartupInfo;
 import python.lib.Types;
+import python.lib.Tuple;
 
 typedef PopenOptions = {
 	?bufsize : Int,