bytevector improvements
authorStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 17 Oct 2017 11:53:31 +0000 (13:53 +0200)
committerStefan Israelsson Tampe <stefan.itampe@gmail.com>
Tue, 17 Oct 2017 11:53:31 +0000 (13:53 +0200)
modules/language/python/bytes.scm
modules/language/python/compile.scm
modules/language/python/dir.scm
modules/language/python/module/python.scm

index 880e3e738508293d916d967a6a8aaa95494c7775..44c93bc07095316fa80457f4083fa576ab01ccd8 100644 (file)
@@ -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))
 (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
     (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)
 
 (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))
 (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))
         (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)))
     (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))))
   
       (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))
             (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))
                   (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))
                         (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))
 
 (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))
                        (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)
             (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))
     (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)
                 (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)))
 ;;;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)))
                    (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))
              (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))
             (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
               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))
 |#
 
 (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))))
 (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)
                       (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))
                   (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))
                 (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)
             (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)
             (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)
                  (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))
      (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))
        (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)
               (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)))
               (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
 (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
                   (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)))
 
                  ((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)
                 (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))
 
 (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)
                            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))
index 0126bbdd4a76deccda57d170fd88ec4505b12c2c..7585a1521001274bf29b223333a231ad50089368 100644 (file)
 
  (#: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)
index 8e3c35db25c2a3eab29fa8dc0ff4fd95adfbed9c..30e47ac7ddcc8bdab0cd4b4e59c3f2e945d606be 100644 (file)
@@ -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)
           (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))
 (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)
index 87bbf32216017352f470c5400950e93eb0b139f9..f3b68c1a1bd59066a64a3f8e4eb1d918432f235d 100644 (file)
@@ -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