add bytes index and find

Author: jgirardet

tests/snippets/bytes.py

@@ -207,3 +207,28 @@
 assert b"abcde".startswith(b"cd", 2)
 assert not b"abcde".startswith(b"cd", 1, 4)
 assert b"abcde".startswith((b"a", b"bc"))
+
+
+# index find
+assert b"abcd".index(b"cd") == 2
+assert b"abcd".index(b"cd", 0) == 2
+assert b"abcd".index(b"cd", 1) == 2
+assert b"abcd".index(99) == 2
+with assertRaises(ValueError):
+    b"abcde".index(b"c", 3, 1)
+with assertRaises(ValueError):
+    b"abcd".index(b"cdaaaaa")
+with assertRaises(ValueError):
+    b"abcd".index(b"b", 3, 4)
+with assertRaises(ValueError):
+    b"abcd".index(1)
+
+
+assert b"abcd".find(b"cd") == 2
+assert b"abcd".find(b"cd", 0) == 2
+assert b"abcd".find(b"cd", 1) == 2
+assert b"abcde".find(b"c", 3, 1) == -1
+assert b"abcd".find(b"cdaaaaa") == -1
+assert b"abcd".find(b"b", 3, 4) == -1
+assert b"abcd".find(1) == -1
+assert b"abcd".find(99) == 2

vm/src/obj/objbyteinner.rs

@@ -552,6 +552,44 @@ impl PyByteInner {
 
         Ok(vm.new_bool(suff.as_slice() == &self.elements.do_slice(range)[offset]))
     }
+
+    pub fn find(
+        &self,
+        sub: PyObjectRef,
+        start: OptionalArg<PyObjectRef>,
+        end: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> Result<isize, PyObjectRef> {
+        let sub = match try_as_bytes_like(&sub) {
+            Some(value) => value,
+            None => match_class!(sub,
+                i @ PyInt => 
+                    vec![i.as_bigint().byte_or(vm)?],
+                obj => {return Err(vm.new_type_error(format!("a bytes-like object is required, not {}", obj)));}),
+        };
+
+        let range = self.elements.get_slice_range(
+            &is_valid_slice_arg(start, vm)?,
+            &is_valid_slice_arg(end, vm)?,
+        );
+
+        // not allowed for this method
+        if range.end < range.start {
+            return Ok(-1isize);
+        }
+
+        let start = range.start;
+
+        let slice = &self.elements[range];
+        for (n, _) in slice.iter().enumerate() {
+            if n + sub.len() <= slice.len()
+                && &slice[n..n + sub.len()] == sub.as_slice()
+            {
+                return Ok((start+n) as isize);
+            }
+        }
+        Ok(-1isize)
+    }
 }
 
 pub fn try_as_byte(obj: &PyObjectRef) -> Option<Vec<u8>> {

vm/src/obj/objbytes.rs

@@ -280,6 +280,32 @@ impl PyBytesRef {
     ) -> PyResult {
         self.inner.startsendswith(suffix, start, end, false, vm)
     }
+
+    #[pymethod(name = "find")]
+    fn find(
+        self,
+        sub: PyObjectRef,
+        start: OptionalArg<PyObjectRef>,
+        end: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        Ok(vm.new_int(self.inner.find(sub, start, end, vm)?))
+    }
+
+    #[pymethod(name = "index")]
+    fn index(
+        self,
+        sub: PyObjectRef,
+        start: OptionalArg<PyObjectRef>,
+        end: OptionalArg<PyObjectRef>,
+        vm: &VirtualMachine,
+    ) -> PyResult {
+        let res = self.inner.find(sub, start, end, vm)?;
+        if res == -1 {
+            return Err(vm.new_value_error("substring not found".to_string()));
+        }
+        Ok(vm.new_int(res))
+    }
 }
 
 #[derive(Debug)]