Documentation ¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
var B64Decode = rnt.NewSimpleFunction("b64decode", []string{"s", "url"}, func(args []rnt.Object) rnt.Object { var bytes []byte if args[0].IsInstance(rnt.BytesType) { bytes = args[0].(rnt.Bytes).Value() } else { bytes = []byte(args[0].(rnt.Str).Value()) } enc := base64.StdEncoding if args[1].(rnt.Int).Value() != 0 { enc = base64.URLEncoding } result := make([]byte, enc.DecodedLen(len(bytes))) n, err := enc.Decode(result, bytes) if err != nil { panic(rnt.RaiseType(BinasciiErrorType, "Invalid base64 input")) } return rnt.NewBytes(result[:n]...) })
B64Decode implements python/base64.b64decode (mostly)
var B64Encode = rnt.NewSimpleFunction("b64encode", []string{"s", "url"}, func(args []rnt.Object) rnt.Object { bytes := args[0].(rnt.Bytes).Value() enc := base64.StdEncoding if args[1].(rnt.Int).Value() != 0 { enc = base64.URLEncoding } result := make([]byte, enc.EncodedLen(len(bytes))) enc.Encode(result, bytes) return rnt.NewBytes(result...) })
B64Encode implements python/base64.b64encode (mostly)
var BinasciiErrorType = rnt.Cal( rnt.TypeType, rnt.NewStr("binascii.Error"), rnt.NewTuple(rnt.ValueErrorType), rnt.NewDict()).(rnt.Type)
BinasciiErrorType is the error type raised by the binascii functions ..
var GetDecoder = rnt.NewSimpleFunction("getdecoder", []string{"encoding"}, func(args []rnt.Object) rnt.Object { encoding := args[0].(rnt.Str).Value() decoder := rnt.GetCodec(encoding).Decode return rnt.NewFunction(namifyEncoding(encoding)+"_decode", []rnt.Param{ {Name: "s"}, {Name: "errors", Def: rnt.NewStr("strict")}, }, 0, false, false, func(args []rnt.Object) rnt.Object { res, cnt := decoder(args[0], args[1].(rnt.Str)) return rnt.NewTuple(res, cnt) }) })
GetDecoder returns the decoder function of the codec corresponding to encoding.
var GetEncoder = rnt.NewSimpleFunction("getencoder", []string{"encoding"}, func(args []rnt.Object) rnt.Object { encoding := args[0].(rnt.Str).Value() encoder := rnt.GetCodec(encoding).Encode return rnt.NewFunction(namifyEncoding(encoding)+"_encode", []rnt.Param{ {Name: "obj"}, {Name: "errors", Def: rnt.NewStr("strict")}, }, 0, false, false, func(args []rnt.Object) rnt.Object { res, cnt := encoder(args[0], args[1].(rnt.Str)) return rnt.NewTuple(res, cnt) }) })
GetEncoder returns the encoder function of the codec corresponding to encoding.
var HTMLParse = rnt.NewSimpleFunction("HTMLParse", []string{"s", "cb_starttag"}, func(args []rnt.Object) rnt.Object { s := args[0].(rnt.Str).Value() cbStartTag := args[1] doc, err := html.Parse(strings.NewReader(s)) if err != nil { panic(rnt.RaiseType(HTMLParseErrorType, err.Error())) } var visit func(*html.Node) visit = func(n *html.Node) { if n.Type == html.ElementNode { attrs := make([]rnt.Object, len(n.Attr)) for i, attr := range n.Attr { attrs[i] = rnt.NewTuple(rnt.NewStr(attr.Key), rnt.NewStr(attr.Val)) } rnt.Cal(cbStartTag, rnt.NewStr(n.Data), rnt.NewList(attrs...)) } for c := n.FirstChild; c != nil; c = c.NextSibling { visit(c) } } visit(doc) return rnt.None })
HTMLParse parses s as an HTML document, and calls the cb_starttag(tag, attrs) callback for each tag encountered (attrs is a list of (key,value) tuples).
var HTMLParseErrorType = rnt.Cal( rnt.TypeType, rnt.NewStr("HTMLParseError"), rnt.NewTuple(rnt.ExceptionType), rnt.NewDict()).(rnt.Type)
HTMLParseErrorType is the error type raised by HTML parsing
var Hexlify = rnt.NewSimpleFunction("hexlify", []string{"data"}, func(args []rnt.Object) rnt.Object { data := args[0].(rnt.Bytes) bytes := data.Value() result := make([]byte, hex.EncodedLen(len(bytes))) hex.Encode(result, bytes) return rnt.NewBytes(result...) })
Hexlify implements python/binascii.hexlify
var JSONDumps = rnt.NewSimpleFunction("dumps", []string{"obj"}, func(args []rnt.Object) rnt.Object { obj := args[0] b, err := json.Marshal(jsonUnwrap(obj)) if err != nil { panic(rnt.RaiseType(rnt.TypeErrorType, err.Error())) } return rnt.NewStr(string(b)) })
JSONDumps implements python/json.dumps
var JSONLoads = rnt.NewSimpleFunction("loads", []string{"s"}, func(args []rnt.Object) rnt.Object { s := args[0].(rnt.Str).Value() var v interface{} if err := json.Unmarshal([]byte(s), &v); err != nil { panic(rnt.RaiseType(rnt.ValueErrorType, err.Error())) } return jsonWrap(v) })
JSONLoads implements python/json.loads
var Unhexlify = rnt.NewSimpleFunction("unhexlify", []string{"hexstr"}, func(args []rnt.Object) rnt.Object { hexstr := args[0].(rnt.Bytes) bytes := hexstr.Value() result := make([]byte, hex.DecodedLen(len(bytes))) _, err := hex.Decode(result, bytes) if err != nil { panic(rnt.RaiseType(BinasciiErrorType, "Invalid hex input")) } return rnt.NewBytes(result...) })
Unhexlify implements python/binascii.unhexlify
var XMLElementInfos = rnt.NewSimpleFunction("XMLElementInfos", []string{"element"}, func(args []rnt.Object) rnt.Object { el := rnt.UnwrapNative(args[0]).(*xmlElement) tag := rnt.NewStr(el.ee.Tag) text := rnt.NewStr(el.ee.Text()) attrib := rnt.NewDict() for _, attr := range el.ee.Attr { attrib.SetItem(rnt.NewStr(attr.Key), rnt.NewStr(attr.Value)) } childno := rnt.NewInt(len(el.ee.ChildElements())) return rnt.NewTuple(tag, text, attrib, childno) })
XMLElementInfos returns (tag, text, attrib, childno) tuple for the provided element
var XMLFind = rnt.NewSimpleFunction("XMLFind", []string{"element", "path"}, func(args []rnt.Object) rnt.Object { el := rnt.UnwrapNative(args[0]).(*xmlElement) path, _ := lib.StringlikeVal(args[1]) path = fixPath(el, path) resEl := el.ee.FindElement(path) if resEl == nil { return rnt.None } return rnt.NewNative(newXMLElement(el, resEl)) })
XMLFind implements python/xml.etree.ElementTree.Element.find()
var XMLFindAll = rnt.NewSimpleFunction("XMLFindAll", []string{"element", "path"}, func(args []rnt.Object) rnt.Object { el := rnt.UnwrapNative(args[0]).(*xmlElement) path, _ := lib.StringlikeVal(args[1]) path = fixPath(el, path) res := []rnt.Object{} for _, resEl := range el.ee.FindElements(path) { res = append(res, rnt.NewNative(newXMLElement(el, resEl))) } return rnt.NewList(res...) })
XMLFindAll implements python/xml.etree.ElementTree.Element.findall()
var XMLGetChildElement = rnt.NewSimpleFunction("XMLGetChildElement", []string{"element", "idx"}, func(args []rnt.Object) rnt.Object { el := rnt.UnwrapNative(args[0]).(*xmlElement) idx := args[1].(rnt.Int).Value() children := el.ee.ChildElements() if idx >= len(children) { panic(rnt.Raise(rnt.IndexErrorType)) } child := children[idx] return rnt.NewNative(newXMLElement(el, child)) })
XMLGetChildElement return the idx-th child element of element
var XMLParse = rnt.NewSimpleFunction("XMLParse", []string{"data"}, func(args []rnt.Object) rnt.Object { data, _ := lib.StringlikeVal(args[0]) doc := etree.NewDocument() doc.ReadSettings.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) { return input, nil } err := doc.ReadFromString(data) if err != nil { panic(rnt.RaiseType(XMLParseErrorType, err.Error())) } root := doc.Root() if root == nil { return rnt.None } return rnt.NewNative(newXMLElement(nil, root)) })
XMLParse implements python/xml.etree.ElementTree.XML
var XMLParseErrorType = rnt.Cal( rnt.TypeType, rnt.NewStr("XMLParseError"), rnt.NewTuple(rnt.ExceptionType), rnt.NewDict()).(rnt.Type)
XMLParseErrorType is the error type raised by XML parsing ..
Functions ¶
This section is empty.
Types ¶
This section is empty.