bytevector improvements

4 files changed, 242 insertions, 166 deletions

diff --git a/modules/language/python/bytes.scm b/modules/language/python/bytes.scm
index 880e3e7..44c93bc 100644
--- a/modules/language/python/bytes.scm
+++ b/modules/language/python/bytes.scm
@@ -10,7 +10,8 @@
   #:use-module (language python exceptions)
   #:use-module (language python list)
   #:use-module (language python hash)
-  #:export (<py-bytes> pybytes-listing bytes bytevector bytes->bytevector))
+  #:export (<py-bytes> pybytes-listing bytes bytearray bytes->bytevector
+		       <py-bytearray> pybytesarray-listing))
 
 (define (bytes->bytevector x) (slot-ref x 'bytes))
 (define-syntax-rule (aif it p x y) (let ((it p)) (if it x y)))
@@ -42,7 +43,9 @@
 (define-python-class bytes (<py-bytes>)
   (define __init__
     (case-lambda
-      ((self s)
+     ((self)
+      (__init__ self ""))
+     ((self s)
        (cond
         ((is-a? s <string>)
          (let* ((n    (string-length s))
@@ -81,44 +84,46 @@
 (define-python-class bytearray (<py-bytearray>)
   (define __init__
     (case-lambda
-      ((self s)
-       (cond
-        ((is-a? s <string>)
-         (let* ((n    (string-length s))
-                (bytes  (b-make n)))
-           (let lp ((i 0))
-             (if (< i n)
-                 (begin
-                   (b-set! bytes i (ch-find (string-ref s i)))
-                   (lp (+ i 1)))))
-           (slot-set! self 'vec bytes)
-           (slot-set! self 'n   n)))
-        ((is-a? s <py-string>)
-         (__init__ self (slot-ref s 'str)))        
-        ((is-a? s <py-bytes>)
-         (let ((b (slot-ref s 'bytes)))
-           (slot-set! self 'vec (bytevector-copy b))
-           (slot-set! self 'n   (b-len b))))
-        ((is-a? s <bytevector>)
-         (slot-set! self 'vec (bytevector-copy s))
-         (slot-set! self 'n   (b-len s)))
-        ((is-a? s <py-bytearray>)
-         (slot-set! self 'vec (bytevector-copy (slot-ref s 'vec)))
-         (slot-set! self 'n   (slot-ref s 'n)))
-        (else        
-         (for ((x : s)) ((r '()))
-              (cons (b-char x) r)
-              #:final
-              (let* ((n   (length r))
-                     (bytes (b-make n)))
-                (let lp ((i (- n 1)) (r r))
-                  (if (>= i 0)
-                      (begin
-                        (b-set! bytes i (car r))
-                        (lp (- i 1) (cdr r)))
-                      (begin
-                        (slot-set! self 'vec bytes)
-                        (slot-set! self 'n (b-len bytes)))))))))))))
+     ((self)
+      (__init__ self ""))
+     ((self s)
+      (cond
+       ((is-a? s <string>)
+	(let* ((n     (string-length s))
+	       (bytes (b-make n)))
+	  (let lp ((i 0))
+	    (if (< i n)
+		(begin
+		  (b-set! bytes i (ch-find (string-ref s i)))
+		  (lp (+ i 1)))))
+	  (slot-set! self 'vec bytes)
+	  (slot-set! self 'n   n)))
+       ((is-a? s <py-string>)
+	(__init__ self (slot-ref s 'str)))        
+       ((is-a? s <py-bytes>)
+	(let ((b (slot-ref s 'bytes)))
+	  (slot-set! self 'vec (bytevector-copy b))
+	  (slot-set! self 'n   (b-len b))))
+       ((is-a? s <bytevector>)
+	(slot-set! self 'vec (bytevector-copy s))
+	(slot-set! self 'n   (b-len s)))
+       ((is-a? s <py-bytearray>)
+	(slot-set! self 'vec (bytevector-copy (slot-ref s 'vec)))
+	(slot-set! self 'n   (slot-ref s 'n)))
+       (else        
+	(for ((x : s)) ((r '()))
+	     (cons (b-char x) r)
+	     #:final
+	     (let* ((n   (length r))
+		    (bytes (b-make n)))
+	       (let lp ((i (- n 1)) (r r))
+		 (if (>= i 0)
+		     (begin
+		       (b-set! bytes i (car r))
+		       (lp (- i 1) (cdr r)))
+		     (begin
+		       (slot-set! self 'vec bytes)
+		       (slot-set! self 'n (b-len bytes)))))))))))))
 
 (define-syntax-rule (define-py (f o . u) code ...)
   (begin
@@ -130,9 +135,9 @@
     (define-method (f (o <py-bytearray>) . u) code ...)))
 
 (define (idd x) x)
-(define-syntax-rule (define-py* (f m o n . u) code ...)
+(define-syntax-rule (define-py* g (f m o nn . u) code ...)
   (begin
-    (define (g m o n . u) code ...)
+    (define (g m o nn . u) code ...)
     (define-method (f (o <bytevector>) . l)
       (apply g idd o (b-len o) l))
     (define-method (f (o <py-bytes>) . l)
@@ -145,11 +150,15 @@
 
 (define-method (write (b <py-bytes>) . l)
   (define port (if (pair? l) (car l) #t))
-  (format port "b~s" (b->string (slot-ref b 'bytes))))
+  (format port "b'")
+  (b->string port (slot-ref b 'bytes))
+  (format port "'"))
 
 (define-method (write (b <py-bytearray>) . l)
   (define port (if (pair? l) (car l) #t))
-  (format port "ba~s" (b->string (pylist-slice (slot-ref b 'vec) 0 (len b) 1))))
+  (format port "bytearray(b'")
+  (b->string port (pylist-slice (slot-ref b 'vec) 0 (len b) 1))
+  (format port "')"))
 
 
 (define dynlink (dynamic-link))
@@ -157,7 +166,7 @@
 (define stringn
   (pointer->procedure
    '*
-   (dynamic-func "scm_from_locale_stringn" dynlink)
+   (dynamic-func "scm_from_latin1_stringn" dynlink)
    (list '* size_t)))
 
 (define ch->i (make-hash-table))
@@ -189,37 +198,60 @@
         (string-ref bytes 0)
         (chf 0))))
 
-(define (b->string b)
-  (pointer->scm
-   (stringn (bytevector->pointer b) (b-len b))))
-
-(define-py (py-hash b) (hash b pyhash-N))
-
-(define-py (pylist-ref o nin)
-  (define N (b-len o))
-  (define n (if (< nin 0) (+ N nin) nin))
-  (if (and (>= n 0) (< n N))
-      (bytes (b-make (b-ref o n)))
-      (raise IndexError)))
-
-(define-py! (pylist-ref o nin)
-  (define N (slot-ref o 'n))
-  (define v (slot-ref o 'vec))
+(define (b->string port b)
+  (let ((n (b-len b)))
+    (let lp ((i 0))
+      (if (< i n)
+	  (let ((ch (b-ref b i)))
+	    (cond
+	     ((equal? ch 0)
+	      (format port "\\x00"))
+	     ((equal? (chf ch) #\\)
+	      (format port "\\\\"))
+	     ((equal? (chf ch) #\')
+	      (format port "\\'"))
+	     ((equal? (chf ch) #\newline)
+	      (format port "\\n"))
+	     ((= ch 7)
+	      (format port "\\a"))
+	     ((= ch 8)
+	      (format port "\\b"))
+	     ((= ch 12)
+	      (format port "\\f"))
+	     ((= ch 10)
+	      (format port "\\n"))
+	     ((= ch 13)
+	      (format port "\\r"))
+	     ((= ch 9)
+	      (format port "\\t"))
+	     ((= ch 11)
+	      (format port "\\v"))
+	     (else
+	      (if (< ch 32)		  
+		  (format port "\\x~2,'0x" ch)
+		  (format port "~a"      (make-string 1 (chf ch))))))
+	    (lp (+ i 1)))))))
+
+(define-py  (py-hash b) (hash b pyhash-N))
+
+(define-py* pylist (pylist-ref bytes o N nin)
   (define n (if (< nin 0) (+ N nin) nin))
   (if (and (>= n 0) (< n N))
-      (bytes (b-make (b-ref v n)))
+      (if (eq? bytes idd)
+	  (b-ref o n)
+	  (bytes (b-make 1 (b-ref o n))))
       (raise IndexError)))
 
 (define-py  (len b) (b-len b))
 (define-py! (len b) (slot-ref b 'n))
 
-(define-py* (to-list mk b n)
+(define-py* ->list (to-list mk b n)
   (let lp ((i 0) (r '()))
     (if (< i n)
         (lp (+ i 1) (cons (b-ref b i) r))
         (reverse r))))
 
-(define-py* (to-pylist mk b n)
+(define-py* ->pylist (to-pylist mk b n)
   (let* ((m n)
          (o (make <py-list>))
          (v (make-vector m)))
@@ -228,7 +260,9 @@
     (let lp ((i 0))
       (if (< i n)
           (begin
-            (vector-set! v i (bytes (b-make 1 (b-ref b i))))            
+            (vector-set! v i (if (equal? bytes idd)
+				 (b-ref b i)
+				 (bytes (b-make 1 (b-ref b i)))))
             (lp (+ i 1)))
           o))))
   
@@ -240,13 +274,12 @@
       (b-set! (slot-ref o 'vec) n val)
       (raise IndexError)))
 
-(define-py (pylist-slice o n1 n2 n3)
-  (define N (b-len o))
+(define-py* slice (pylist-slice bytes o N n1 n2 n3)
   (define (f n) (if (< n 0) (+ N n) n))
     
-  (let* ((n1   (f (if (eq? n1 None) 0                n1)))
-         (n2   (f (if (eq? n2 None) (slot-ref o 'n)  n2)))
-         (n3   (f (if (eq? n3 None) 1                n3)))
+  (let* ((n1   (f (if (eq? n1 None) 0 n1)))
+         (n2   (f (if (eq? n2 None) N n2)))
+         (n3   (f (if (eq? n3 None) 1 n3)))
          (n    (let lp ((i n1) (j 0))
                  (if (< i n2)
                      (lp (+ i n3) (+ j 1))
@@ -259,29 +292,6 @@
             (lp (+ i n3) (+ j 1)))
           (bytes b)))))
 
-(define-py! (pylist-slice o n1 n2 n3)
-  (define N (slot-ref o 'n))
-  (define (f n) (if (< n 0) (+ N n) n))
-    
-  (let* ((n1   (f (if (eq? n1 None) 0                n1)))
-         (n2   (f (if (eq? n2 None) (slot-ref o 'n)  n2)))
-         (n3   (f (if (eq? n3 None) 1                n3)))
-         (v    (slot-ref o 'vec))
-         (n    (let lp ((i n1) (j 0))
-                 (if (< i n2)
-                     (lp (+ i n3) (+ j 1))
-                     j)))
-         (b    (b-make n))
-         (r    (make <py-bytes>)))
-    (slot-set! r 'vec b)
-    (slot-set! r 'n   n)
-    (let lp ((i n1) (j 0))
-      (if (< j n)
-          (begin
-            (b-set! b j (b-ref v i))
-            (lp (+ i n3) (+ j 1)))
-          r))))
-
 (define-py! (pylist-subset! o n1 n2 n3 val)
   (define N (slot-ref o 'n))
   (define (f n) (if (< n 0) (+ N n) n))
@@ -299,7 +309,7 @@
                   (let ((r (car l2)))
                     (if (and (number? r) (integer? r) (>= r 0) (< r 256))
                         (begin
-                          (vector-set! vec j r)
+                          (b-set! vec j r)
                           (lp (+ i 1) (cdr l2) (+ j n3)))
                         (raise TypeError "not a byte")))
                   (let lp ((j2 j))
@@ -308,13 +318,13 @@
                         (let lp ((k1 j) (k2 j2))
                           (if (< k2 N)
                               (begin
-                                (vector-set! vec k1 (vector-ref vec k2))
+                                (b-set! vec k1 (b-ref vec k2))
                                 (lp (+ k1 1) (+ k2 1)))
                               (begin
                                 (let lp ((i k2))
                                   (if (< i N)
                                       (begin
-                                        (vector-set! vec i #f)
+                                        (b-set! vec i #f)
                                         (lp (+ i 1)))
                                       (slot-set! o 'n k1)))))))))))
         (raise IndexError))
@@ -322,20 +332,18 @@
 
 (define (byte x)
   (or (and (integer? x) (>= x 0) (< x 256) x)
-      (and (is-a? x '<bytevector>)   (b-ref x 0))
-      (and (is-a? x '<py-bytes>)     (b-ref (slot-ref x 'bytes) 0))
-      (and (is-a? x '<py-bytearray>) (b-ref (slot-ref x 'vec)   0))))
+      (and (is-a? x <bytevector>)   (b-ref x 0))
+      (and (is-a? x <py-bytes>)     (b-ref (slot-ref x 'bytes) 0))
+      (and (is-a? x <py-bytearray>) (b-ref (slot-ref x 'vec)   0))))
       
 (define-py! (pylist-append! o val)
   (let* ((n   (slot-ref o 'n))
          (vec (slot-ref o 'vec))
-         (N   (vector-length vec)))
-    (aif val (byte val)
+	 (N   (b-len vec)))
+    (aif v (byte val)
          (begin
            (if (< n N)
-               (begin
-                 (vector-set! vec n val)
-                 (slot-set! o 'n (+ n 1)))
+	       (b-set! vec n v)
                (let* ((N    (* 2 N))
                       (vec2 (b-make N)))
                  (let lp ((i 0))
@@ -343,11 +351,11 @@
                        (begin
                          (b-set! vec2 i (b-ref vec i))
                          (lp (+ i 1)))))
-                 (b-set! vec2 n val)
+                 (b-set! vec2 n v)
                  (slot-set! o 'vec vec2)))
            (slot-set! o 'n (+ n 1))
            (values))
-         (raise TypeError "not a byte"))))
+         (raise TypeError "not a byte" val))))
 
   
 (define (b-concat b1 n1 b2 n2)
@@ -359,10 +367,11 @@
             (b-set! b i (b-ref b1 i))
             (lp (+ i 1)))
           (let lp ((i i) (j 0))
-            (begin
-              (b-set! b i (b-ref b2 j))
-              (lp (+ i 1) (+ j 1)))
-            b)))))
+	    (if (< j n2)
+		(begin
+		  (b-set! b i (b-ref b2 j))
+		  (lp (+ i 1) (+ j 1)))
+		b))))))
 
 (define-method (+ (o1 <py-bytes>) (b2 <bytevector>))
   (let* ((b1 (slot-ref o1 'bytes))
@@ -484,7 +493,7 @@
     (slot-set! o 'bytes b)
     o))
 
-(define-py* (py-capitalize bytes s n)
+(define-py* cap (py-capitalize bytes s n)
   (let* ((w (b-make n)))
     (let lp ((i 0) (first? #t))
       (if (< i n)
@@ -503,7 +512,7 @@
                 (f #f)))
           (bytes w)))))
 
-(define-py* (py-center bytes o n w . l)
+(define-py* center (py-center bytes o n w . l)
   (let* ((ws (if (pair? l)
                  (ch-find (b-ref (car l) 0))
                  (ch-find #\space)))
@@ -521,7 +530,7 @@
 ;;;py-decode
 ;;;py-encode
 
-(define-py* (py-endswith bytes o n suff . l)
+(define-py* endswith (py-endswith bytes o n suff . l)
   (let* ((suff (slot-ref (bytes suff) 'bytes))
          (ns   (b-len suff))
          (f    (lambda (x) (< x 0) (+ n x) x)))
@@ -540,7 +549,7 @@
                    (eq? (b-ref o i) (b-ref suff j))
                    (lp (+ i 1) (+ j 1))))))))))
 
-(define-py* (py-startswith bytes o n pre . l)
+(define-py* startswith (py-startswith bytes o n pre . l)
   (let* ((pre (slot-ref (bytes pre) 'bytes))
          (pre (b-get pre))
          (ns  (len pre))
@@ -564,7 +573,7 @@
              (lp (+ i 1))))))))))
 
 
-(define-py* (py-expandtabs bytes s n . l)
+(define-py* expand (py-expandtabs bytes s n . l)
   (let* ((tabsize (match l (() 8) ((x) x)))
          (ct      (ch-find #\tab))
          (cs      (ch-find #\space))
@@ -596,7 +605,7 @@
             (lp (+ i 1)))
         #f)))
 
-(define-py* (py-find bytes s n sub . l)
+(define-py* find (py-find bytes s n sub . l)
   (let* ((f   (lambda (x) (< x 0) (+ n x) x)))
     (call-with-values (lambda ()
                         (match l
@@ -621,7 +630,7 @@
               r)))))
          
 
-(define-py* (py-rfind bytes s n sub . l)  
+(define-py* rfind (py-rfind bytes s n sub . l)  
   (let* ((sub (slot-ref (bytes sub) 'bytes))
          (s    (b-reverse s n))
          (nsub (len sub))
@@ -679,7 +688,7 @@
 |#
 
 (define-syntax-rule (mk-is py-isalnum x ...)
-  (define-py* (py-isalnum bytes s n)
+  (define-py* isalnum (py-isalnum bytes s n)
     (let lp ((i 0))
       (if (< i n)
           (let ((ch (chf (b-ref s i))))
@@ -696,7 +705,7 @@
 (mk-is py-isupper char-upper-case?)
 
 
-(define-py* (py-istitle bytes s n)
+(define-py* istitle (py-istitle bytes s n)
   (if ((> n 0))
       (let lp ((i 0) (space? #t))
         (if (< i n)
@@ -750,10 +759,10 @@
                       (lp l i)))))
           (bytes r)))))
 
-(define-py* (py-join bytes s n iterator)
+(define-py* join (py-join bytes s n iterator)
   (b-join bytes (to-list iterator) s n))
             
-(define-py* (py-ljust bytes s n width . l)
+(define-py* ljust (py-ljust bytes s n width . l)
   (let* ((ch (match l
                ((x)
                 (b-char x))
@@ -769,7 +778,7 @@
                   (lp (+ i 1)))
                 (bytes ret)))))))
 
-(define-py* (py-rjust bytes s n width . l)
+(define-py* rjust (py-rjust bytes s n width . l)
   (let* ((ch (match l
                ((x)
                 (b-char x))
@@ -786,7 +795,7 @@
                 (bytes ret)))))))
 
 
-(define-py* (py-lower bytes s n)
+(define-py* lower (py-lower bytes s n)
   (let* ((r (b-make n)))
     (let lp ((i 0))
       (if (< i n)
@@ -798,7 +807,7 @@
             (lp (+ i 1)))
           (bytes r)))))
 
-(define-py* (py-upper bytes s n)
+(define-py* upper (py-upper bytes s n)
   (let* ((r (b-make n)))
     (let lp ((i 0))
       (if (< i n)
@@ -810,7 +819,7 @@
             (lp (+ i 1)))
           (bytes r)))))
 
-(define-py* (py-swapcase bytes s n)
+(define-py* swapcase (py-swapcase bytes s n)
   (let* ((r (b-make n)))
     (let lp ((i 0))
       (if (< i n)
@@ -856,7 +865,7 @@
                  (lp (- i 1) (cons x r) #f)))
            (bytes r))))))
 
-(define-py* (py-lstrip bytes s n . l)
+(define-py* lstrip (py-lstrip bytes s n . l)
   (match l
     (()
      (b-trim bytes s n))
@@ -864,7 +873,7 @@
      (let ((l (map b-char (to-list x))))
        (b-trim bytes s n (lambda (ch x) (member x l)))))))
 
-(define-py* (py-rstrip bytes s n . l)
+(define-py* restrip (py-rstrip bytes s n . l)
   (match l
     (()
      (b-rtrim bytes s n))
@@ -873,7 +882,7 @@
        (b-rtrim bytes s n (lambda (ch x) (member x l)))))))
 
 
-(define-py* (py-partition bytes s n sep)
+(define-py* partition (py-partition bytes s n sep)
   (let* ((sep (b-get sep))
          (m   (b-len sep)))
     (define (test i)
@@ -892,7 +901,7 @@
               (lp (+ i 1)))
           (list s "" "")))))
 
-(define-py* (py-rpartition bytes ss n ssep)
+(define-py* rpartition (py-rpartition bytes ss n ssep)
   (let* ((s    (b-reverse ss n))
          (m    (len ssep))
          (sep  (b-reverse (b-get ssep) m)))
@@ -920,7 +929,7 @@
               (lp (+ i 1)))
           (list (bytes "") (bytes "") s)))))
 
-(define-py* (py-replace bytes s n old new . l)
+(define-py* replace (py-replace bytes s n old new . l)
   (let ((n (match l (() #f) ((n . _) n))))
     (b-join
      bytes
@@ -939,7 +948,7 @@
 (define-py! (py-stripip s . l)
   (apply py-rstrip (apply py-lstrip s l) l))
 
-(define-py* (pylist-index bytes o n val . l)
+(define-py* index (pylist-index bytes o n val . l)
   (let* ((vec o)
          (f   (lambda (m) (if (< m 0) (+ m n) m))))
     (call-with-values
@@ -962,7 +971,7 @@
                   (raise ValueError "could not find value in index fkn")))
             (raise IndexError "index out of scop in index fkn"))))))
 
-(define-py* (py-rindex býtes s n . l) 
+(define-py* rindex (py-rindex býtes s n . l) 
   (let ((n (b-len s)))
     (- n (apply pylist-index (b-reverse s n) l) 1)))
 
@@ -1010,7 +1019,7 @@
                  ((sep . l) (cons (string-reverse sep) l)))))))
 
 
-(define-py* (py-splitlines bytes s n . l)
+(define-py* splitlines (py-splitlines bytes s n . l)
   (let ((keep? (match l
                  ((#:keepends v)
                   v)
@@ -1036,7 +1045,7 @@
                 (lp (+ i 1) r old)))
           (reverse r)))))
         
-(define-py* (py-translate bytes s n table . l)
+(define-py* translate (py-translate bytes s n table . l)
   (let* ((table (b-get table))
          (w (b-make n))
          (t (if (eq? table None) #f table))
@@ -1070,42 +1079,64 @@
 
 (define-syntax-rule (a b x y) (b (symbol->string x) (symbol->string y)))
 
+(define (cmp op s1 n1 s2 n2)
+  (let ((n (min n1 n2)))
+    (let lp ((i 0))
+      (if (< i n)
+	  (let ((x1 (b-ref s1 i))
+		(x2 (b-ref s2 i)))
+	    (if (= x1 x2)
+		(lp (+ i 1))
+		(op x1 x2)))
+	  (op n1 n2)))))
+
+
 (define-syntax-rule (mkop op)
  (begin
-   (define-method (op (s1 <bytevector>) (s2 <py-bytes>))
-     (op s1 (slot-ref s2 'bytes)))
-   (define-method (op (s2 <py-bytes>) (s1 <bytevector>))
-     (op s1 (slot-ref s2 'bytes)))))
-
+   (define-method (op (b1 <bytevector>) (s2 <py-bytes>))
+     (let ((b2 (slot-ref s2 'bytes)))
+       (cmp op b1 (b-len b1) b2 (b-len b2))))
+   (define-method (op (s1 <py-bytes>) (b2 <bytevector>) )
+     (let ((b1 (slot-ref s1 'bytes)))
+       (cmp op b1 (b-len b1) b2 (b-len b2))))
+   (define-method (op (b1 <bytevector>) (b2 <bytevector>) )
+     (cmp op b1 (b-len b1) b2 (b-len b2)))
+   (define-method (op (s1 <py-bytes>) (s2 <py-bytes>) )
+     (let ((b1 (slot-ref s1 'bytes))
+	   (b2 (slot-ref s2 'bytes)))
+       (cmp op b1 (b-len b1) b2 (b-len b2))))
+   (define-method (op (a1 <py-bytearray>) (b2 <bytevector>))
+     (let ((b1 (slot-ref a1 'vec))
+	   (n1 (slot-ref a1 'n)))
+       (cmp op b1 n1 b2 (b-len b2))))
+   (define-method (op (b1 <bytevector>) (a2 <py-bytearray>))
+     (let ((b2 (slot-ref a2 'vec))
+	   (n2 (slot-ref a2 'n)))
+       (cmp op b1 (b-len b1) b2 n2)))
+   (define-method (op (a1 <py-bytearray>) (s2 <py-bytes>))
+     (let ((b1 (slot-ref a1 'vec))
+	   (n1 (slot-ref a1 'n))
+	   (b2 (slot-ref s2 'bytes)))
+       (cmp op b1 n1 b2 (b-len b2))))
+   (define-method (op (s1 <py-bytes>) (a2 <py-bytearray>))
+     (let ((b2 (slot-ref a2 'vec))
+	   (n2 (slot-ref a2 'n))
+	   (b1 (slot-ref s1 'bytes)))
+       (cmp op b1 (b-len b1) b2 n2)))
+   (define-method (op (a1 <py-bytearray>) (a2 <py-bytearray>))
+     (let ((b1 (slot-ref a1 'vec))
+	   (n1 (slot-ref a1 'n  ))
+	   (b2 (slot-ref a2 'vec))
+	   (n2 (slot-ref a2 'n  )))
+       (cmp op b1 n1 b2 n2)))))
+   
 (mkop <)
 (mkop <=)
 (mkop >)
 (mkop >=)
 (mkop py-equal?)
-(mkop +)
-(mkop *)
-
-(define-syntax-rule (mkop2 op)
-  (define-method (<  (s1 <bytevector>) (s2 <bytevector>))
-    (let* ((n1 (b-len s1))
-           (n2 (b-len s2))
-           (n  (min n1 n2)))
-      (let lp ((i 0))
-        (if (< i n)
-            (let ((x1 (b-ref s1 i))
-                  (x2 (b-ref s2 i)))
-              (if (= x1 x2)
-                  (lp (+ i 1))
-                  (op x1 x2)))
-            (op n1 n2))))))
-
-(mkop2 <)
-(mkop2 <=)
-(mkop2 >=)
-(mkop2 >)
-(mkop2 py-equal?)
-
-(define-py* (py-zfill bytes s n width)
+
+(define-py* zfill (py-zfill bytes s n width)
   (let* ((w (pylist-slice s 0 n 1)))
     (let lp ((i 0))
       (if (< i n)
@@ -1214,5 +1245,27 @@
                            rjust rpartition rsplit rbytesip split splitlines
                            startswith strip swapcase
                            title translate upper zfill)))))
+     (pylist-sort! l)
+    l))
+
+(define (pybytesarray-listing)
+  (let ((l (to-pylist
+            (map symbol->string
+		 '(__add__  __alloc__ __class__ __contains__ __delattr__
+			    __delitem__ __dir__ __doc__ __eq__ __format__
+			    __ge__ __getattribute__ __getitem__ __gt__
+			    __hash__ __iadd__ __imul__ __init__ __iter__
+			    __le__ __len__ __lt__ __mod__ __mul__ __ne__
+			    __new__ __reduce__ __reduce_ex__ __repr__
+			    __rmod__ __rmul__ __setattr__ __setitem__
+			    __sizeof__ __str__ __subclasshook__ append
+			    capitalize center clear copy count decode endswith
+			    expandtabs extend find fromhex hex index insert
+			    isalnum isalpha isdigit islower isspace istitle
+			    isupper join ljust lower lstrip maketrans
+			    partition pop remove replace reverse rfind rindex
+			    rjust rpartition rsplit rstrip split splitlines
+			    startswith strip swapcase title translate upper
+			    zfill)))))
     (pylist-sort! l)
     l))
diff --git a/modules/language/python/compile.scm b/modules/language/python/compile.scm
index 0126bbd..7585a15 100644
--- a/modules/language/python/compile.scm
+++ b/modules/language/python/compile.scm
@@ -1104,7 +1104,10 @@
 
  (#:expr-stmt
   ((_ (l ...) (#:assign))
-   `(,(G 'values) ,@(map (g vs exp) l)))
+   (let ((l (map (g vs exp) l)))
+     (if (= (length l) 1)
+	 (car l)
+	 `(,(G 'values) ,@l))))
    
   ((_ l type)
    (=> fail)
diff --git a/modules/language/python/dir.scm b/modules/language/python/dir.scm
index 8e3c35d..30e47ac 100644
--- a/modules/language/python/dir.scm
+++ b/modules/language/python/dir.scm
@@ -3,7 +3,9 @@
   #:use-module (language python for)
   #:use-module (language python dict)
   #:use-module (language python string)
+  #:use-module (language python bytes)
   #:use-module (language python number)
+  #:use-module (language python bytes)
   #:use-module (oop goops)
   #:use-module (ice-9 vlist)
   #:use-module (oop pf-objects)
@@ -136,6 +138,24 @@
           (pylist-sort! l)
           l)
         l1)))
+
+(define-method (dir (o <py-bytes>))
+  (let ((l1 (pybytes-listing)))
+    (if (is-a? o <p>)
+        (let* ((l2 (next-method))
+               (l  (+ l1 l2)))
+          (pylist-sort! l)
+          l)
+        l1)))
+
+(define-method (dir (o <py-bytearray>))
+  (let ((l1 (pybytesarray-listing)))
+    (if (is-a? o <p>)
+        (let* ((l2 (next-method))
+               (l  (+ l1 l2)))
+          (pylist-sort! l)
+          l)
+        l1)))
           
     
 (define-method (dir (o <hashtable>   )) (pyhash-listing))
@@ -143,7 +163,7 @@
 (define-method (dir (o <complex>     )) (pycomplex-listing))
 (define-method (dir (o <real>        )) (pyfloat-listing))
 (define-method (dir (o <integer>     )) (pyint-listing))
-
+(define-method (dir (o <bytevector>  )) (pybytes-listing))
 (define-method (dir)
   (let ((l '()))
     (module-for-each (lambda (m . u)
diff --git a/modules/language/python/module/python.scm b/modules/language/python/module/python.scm
index 87bbf32..f3b68c1 100644
--- a/modules/language/python/module/python.scm
+++ b/modules/language/python/module/python.scm
@@ -28,7 +28,7 @@
   #:re-export (Exception StopIteration send sendException next
                          GeneratorExit sendClose RuntimeError
                          len dir next dict None property range
-                         tuple bytes
+                         tuple bytes bytearray
 			 )
   #:export (print repr complex float int
                   set all any bin callable reversed