cchecksum 0.0.10__tar.gz → 0.0.12__tar.gz

{cchecksum-0.0.10 → cchecksum-0.0.12}/.github/workflows/pytest.yaml

@@ -48,4 +48,4 @@ jobs:
           pip install -e .
       
       - name: Run test suite
-        run: pytest
+        run: pytest -s -v

{cchecksum-0.0.10 → cchecksum-0.0.12}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.10
-Summary: A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
+Version: 0.0.12
+Summary: A ~4.5x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/cchecksum
 Author: BobTheBuidler
 Author-email: bobthebuidlerdefi@gmail.com

cchecksum-0.0.12/README.md

@@ -0,0 +1,9 @@
+## CChecksum
+
+CChecksum is a ~4.5x faster drop-in replacement for eth_utils.to_checksum_address, with the most cpu-intensive part implemented in c.
+
+It keeps the exact same API as the existing implementation, exceptions and all.
+
+Just `pip install cchecksum`, drop it in, and run your script with a substantial speed improvement.
+
+![image](https://github.com/user-attachments/assets/f2732c1f-f36e-486c-9258-cdeb09bb5eb5)

{cchecksum-0.0.10 → cchecksum-0.0.12}/cchecksum/_checksum.c

@@ -3126,7 +3126,7 @@ static const char __pyx_k_dtype_is_object[] = "dtype_is_object";
 static const char __pyx_k_norm_address_mv[] = "norm_address_mv";
 static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError";
 static const char __pyx_k_setstate_cython[] = "__setstate_cython__";
-static const char __pyx_k_cchecksum_line_3[] = "cchecksum (line 3)";
+static const char __pyx_k_cchecksum_line_4[] = "cchecksum (line 4)";
 static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum";
 static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
 static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
@@ -3148,7 +3148,7 @@ static const char __pyx_k_Step_may_not_be_zero_axis_d[] = "Step may not be zero
 static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array";
 static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data.";
 static const char __pyx_k_strided_and_direct_or_indirect[] = "<strided and direct or indirect>";
-static const char __pyx_k_Computes_the_checksummed_versio[] = "\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ";
+static const char __pyx_k_Computes_the_checksummed_versio[] = "\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x: The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x: The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ";
 static const char __pyx_k_All_dimensions_preceding_dimensi[] = "All dimensions preceding dimension %d must be indexed and not sliced";
 static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides";
 static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory.";
@@ -3300,7 +3300,7 @@ typedef struct {
   PyObject *__pyx_n_s_cchecksum;
   PyObject *__pyx_n_s_cchecksum__checksum;
   PyObject *__pyx_kp_s_cchecksum__checksum_pyx;
-  PyObject *__pyx_kp_u_cchecksum_line_3;
+  PyObject *__pyx_kp_u_cchecksum_line_4;
   PyObject *__pyx_n_s_class;
   PyObject *__pyx_n_s_class_getitem;
   PyObject *__pyx_n_s_cline_in_traceback;
@@ -3507,7 +3507,7 @@ static int __pyx_m_clear(PyObject *m) {
   Py_CLEAR(clear_module_state->__pyx_n_s_cchecksum);
   Py_CLEAR(clear_module_state->__pyx_n_s_cchecksum__checksum);
   Py_CLEAR(clear_module_state->__pyx_kp_s_cchecksum__checksum_pyx);
-  Py_CLEAR(clear_module_state->__pyx_kp_u_cchecksum_line_3);
+  Py_CLEAR(clear_module_state->__pyx_kp_u_cchecksum_line_4);
   Py_CLEAR(clear_module_state->__pyx_n_s_class);
   Py_CLEAR(clear_module_state->__pyx_n_s_class_getitem);
   Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback);
@@ -3692,7 +3692,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
   Py_VISIT(traverse_module_state->__pyx_n_s_cchecksum);
   Py_VISIT(traverse_module_state->__pyx_n_s_cchecksum__checksum);
   Py_VISIT(traverse_module_state->__pyx_kp_s_cchecksum__checksum_pyx);
-  Py_VISIT(traverse_module_state->__pyx_kp_u_cchecksum_line_3);
+  Py_VISIT(traverse_module_state->__pyx_kp_u_cchecksum_line_4);
   Py_VISIT(traverse_module_state->__pyx_n_s_class);
   Py_VISIT(traverse_module_state->__pyx_n_s_class_getitem);
   Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback);
@@ -3887,7 +3887,7 @@ static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) {
 #define __pyx_n_s_cchecksum __pyx_mstate_global->__pyx_n_s_cchecksum
 #define __pyx_n_s_cchecksum__checksum __pyx_mstate_global->__pyx_n_s_cchecksum__checksum
 #define __pyx_kp_s_cchecksum__checksum_pyx __pyx_mstate_global->__pyx_kp_s_cchecksum__checksum_pyx
-#define __pyx_kp_u_cchecksum_line_3 __pyx_mstate_global->__pyx_kp_u_cchecksum_line_3
+#define __pyx_kp_u_cchecksum_line_4 __pyx_mstate_global->__pyx_kp_u_cchecksum_line_4
 #define __pyx_n_s_class __pyx_mstate_global->__pyx_n_s_class
 #define __pyx_n_s_class_getitem __pyx_mstate_global->__pyx_n_s_class_getitem
 #define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback
@@ -17979,8 +17979,8 @@ static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__
   return __pyx_r;
 }
 
-/* "cchecksum/_checksum.pyx":3
- * # cython: boundscheck=False
+/* "cchecksum/_checksum.pyx":4
+ * # cython: wraparound=False
  * 
  * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
@@ -17995,7 +17995,7 @@ PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds
 PyObject *__pyx_args, PyObject *__pyx_kwds
 #endif
 ); /*proto*/
-PyDoc_STRVAR(__pyx_doc_9cchecksum_9_checksum_cchecksum, "cchecksum(unicode norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str\n\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ");
+PyDoc_STRVAR(__pyx_doc_9cchecksum_9_checksum_cchecksum, "cchecksum(unicode norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str\n\n    Computes the checksummed version of an Ethereum address.\n\n    This function takes a normalized Ethereum address (without the '0x' prefix) and its corresponding\n    hash (also without the '0x' prefix) and returns the checksummed address as per the Ethereum\n    Improvement Proposal 55 (EIP-55).\n\n    Args:\n        norm_address_no_0x: The normalized Ethereum address without the '0x' prefix.\n        address_hash_hex_no_0x: The hash of the address, also without the '0x' prefix.\n\n    Returns:\n        The checksummed Ethereum address with the '0x' prefix.\n\n    Examples:\n        >>> cchecksum(\"b47e3cd837ddf8e4c57f05d70ab865de6e193bbb\", \"abcdef1234567890abcdef1234567890abcdef12\")\n        '0xB47E3Cd837DdF8E4C57F05D70Ab865De6E193BbB'\n\n        >>> cchecksum(\"0000000000000000000000000000000000000000\", \"1234567890abcdef1234567890abcdef12345678\")\n        '0x0000000000000000000000000000000000000000'\n\n    See Also:\n        - :func:`eth_utils.to_checksum_address`: A utility function for converting addresses to their checksummed form.\n    ");
 static PyMethodDef __pyx_mdef_9cchecksum_9_checksum_1cchecksum = {"cchecksum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_9cchecksum_9_checksum_1cchecksum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_9cchecksum_9_checksum_cchecksum};
 static PyObject *__pyx_pw_9cchecksum_9_checksum_1cchecksum(PyObject *__pyx_self, 
 #if CYTHON_METH_FASTCALL
@@ -18044,7 +18044,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
           (void)__Pyx_Arg_NewRef_FASTCALL(values[0]);
           kw_args--;
         }
-        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4, __pyx_L3_error)
         else goto __pyx_L5_argtuple_error;
         CYTHON_FALLTHROUGH;
         case  1:
@@ -18052,14 +18052,14 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
           (void)__Pyx_Arg_NewRef_FASTCALL(values[1]);
           kw_args--;
         }
-        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 3, __pyx_L3_error)
+        else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 4, __pyx_L3_error)
         else {
-          __Pyx_RaiseArgtupleInvalid("cchecksum", 1, 2, 2, 1); __PYX_ERR(0, 3, __pyx_L3_error)
+          __Pyx_RaiseArgtupleInvalid("cchecksum", 1, 2, 2, 1); __PYX_ERR(0, 4, __pyx_L3_error)
         }
       }
       if (unlikely(kw_args > 0)) {
         const Py_ssize_t kwd_pos_args = __pyx_nargs;
-        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "cchecksum") < 0)) __PYX_ERR(0, 3, __pyx_L3_error)
+        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "cchecksum") < 0)) __PYX_ERR(0, 4, __pyx_L3_error)
       }
     } else if (unlikely(__pyx_nargs != 2)) {
       goto __pyx_L5_argtuple_error;
@@ -18068,11 +18068,11 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
       values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1);
     }
     __pyx_v_norm_address_no_0x = ((PyObject*)values[0]);
-    __pyx_v_address_hash_hex_no_0x = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(values[1], 0); if (unlikely(!__pyx_v_address_hash_hex_no_0x.memview)) __PYX_ERR(0, 3, __pyx_L3_error)
+    __pyx_v_address_hash_hex_no_0x = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(values[1], 0); if (unlikely(!__pyx_v_address_hash_hex_no_0x.memview)) __PYX_ERR(0, 4, __pyx_L3_error)
   }
   goto __pyx_L6_skip;
   __pyx_L5_argtuple_error:;
-  __Pyx_RaiseArgtupleInvalid("cchecksum", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 3, __pyx_L3_error)
+  __Pyx_RaiseArgtupleInvalid("cchecksum", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 4, __pyx_L3_error)
   __pyx_L6_skip:;
   goto __pyx_L4_argument_unpacking_done;
   __pyx_L3_error:;
@@ -18087,7 +18087,7 @@ PyObject *__pyx_args, PyObject *__pyx_kwds
   __Pyx_RefNannyFinishContext();
   return NULL;
   __pyx_L4_argument_unpacking_done:;
-  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_norm_address_no_0x), (&PyUnicode_Type), 1, "norm_address_no_0x", 1))) __PYX_ERR(0, 3, __pyx_L1_error)
+  if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_norm_address_no_0x), (&PyUnicode_Type), 1, "norm_address_no_0x", 1))) __PYX_ERR(0, 4, __pyx_L1_error)
   __pyx_r = __pyx_pf_9cchecksum_9_checksum_cchecksum(__pyx_self, __pyx_v_norm_address_no_0x, __pyx_v_address_hash_hex_no_0x);
 
   /* function exit code */
@@ -18127,82 +18127,80 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   int __pyx_clineno = 0;
   __Pyx_TraceFrameInit(__pyx_codeobj__9)
   __Pyx_RefNannySetupContext("cchecksum", 1);
-  __Pyx_TraceCall("cchecksum", __pyx_f[0], 3, 0, __PYX_ERR(0, 3, __pyx_L1_error));
+  __Pyx_TraceCall("cchecksum", __pyx_f[0], 4, 0, __PYX_ERR(0, 4, __pyx_L1_error));
 
-  /* "cchecksum/_checksum.pyx":30
+  /* "cchecksum/_checksum.pyx":31
  * 
  *     # Declare memoryviews for fixed-length data
  *     cdef const unsigned char[::1] norm_address_mv = norm_address_no_0x.encode('ascii')             # <<<<<<<<<<<<<<
  * 
  *     # Create a buffer for our result
  */
-  __Pyx_TraceLine(30,0,__PYX_ERR(0, 30, __pyx_L1_error))
+  __Pyx_TraceLine(31,0,__PYX_ERR(0, 31, __pyx_L1_error))
   if (unlikely(__pyx_v_norm_address_no_0x == Py_None)) {
     PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "encode");
-    __PYX_ERR(0, 30, __pyx_L1_error)
+    __PYX_ERR(0, 31, __pyx_L1_error)
   }
-  __pyx_t_1 = PyUnicode_AsASCIIString(__pyx_v_norm_address_no_0x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __pyx_t_1 = PyUnicode_AsASCIIString(__pyx_v_norm_address_no_0x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(__pyx_t_1, 0); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 30, __pyx_L1_error)
+  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dc_unsigned_char__const__(__pyx_t_1, 0); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 31, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
   __pyx_v_norm_address_mv = __pyx_t_2;
   __pyx_t_2.memview = NULL;
   __pyx_t_2.data = NULL;
 
-  /* "cchecksum/_checksum.pyx":34
+  /* "cchecksum/_checksum.pyx":35
  *     # Create a buffer for our result
  *     # 2 for "0x" prefix and 40 for the address itself
  *     cdef unsigned char[42] buffer = b'0x' + bytearray(40)             # <<<<<<<<<<<<<<
  * 
  *     # Handle character casing based on the hash value
  */
-  __Pyx_TraceLine(34,0,__PYX_ERR(0, 34, __pyx_L1_error))
-  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyByteArray_Type)), __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __Pyx_TraceLine(35,0,__PYX_ERR(0, 35, __pyx_L1_error))
+  __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)(&PyByteArray_Type)), __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 35, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_1);
-  __pyx_t_3 = PyNumber_Add(__pyx_kp_b_0x, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __pyx_t_3 = PyNumber_Add(__pyx_kp_b_0x, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_3);
   __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
-  if (unlikely((__Pyx_carray_from_py_unsigned_char(__pyx_t_3, __pyx_t_4, 42) < 0))) __PYX_ERR(0, 34, __pyx_L1_error)
+  if (unlikely((__Pyx_carray_from_py_unsigned_char(__pyx_t_3, __pyx_t_4, 42) < 0))) __PYX_ERR(0, 35, __pyx_L1_error)
   memcpy(&(__pyx_v_buffer[0]), __pyx_t_4, sizeof(__pyx_v_buffer[0]) * (42));
   __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
 
-  /* "cchecksum/_checksum.pyx":40
+  /* "cchecksum/_checksum.pyx":41
  *     cdef int address_char
  * 
  *     for i in range(40):             # <<<<<<<<<<<<<<
  * 
  *         if address_hash_hex_no_0x[i] < 56:
  */
-  __Pyx_TraceLine(40,0,__PYX_ERR(0, 40, __pyx_L1_error))
+  __Pyx_TraceLine(41,0,__PYX_ERR(0, 41, __pyx_L1_error))
   for (__pyx_t_5 = 0; __pyx_t_5 < 40; __pyx_t_5+=1) {
     __pyx_v_i = __pyx_t_5;
 
-    /* "cchecksum/_checksum.pyx":42
+    /* "cchecksum/_checksum.pyx":43
  *     for i in range(40):
  * 
  *         if address_hash_hex_no_0x[i] < 56:             # <<<<<<<<<<<<<<
  *             # '0' to '7' have ASCII values 48 to 55
  *             buffer[i + 2] = norm_address_mv[i]
  */
-    __Pyx_TraceLine(42,0,__PYX_ERR(0, 42, __pyx_L1_error))
+    __Pyx_TraceLine(43,0,__PYX_ERR(0, 43, __pyx_L1_error))
     __pyx_t_6 = __pyx_v_i;
-    if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_address_hash_hex_no_0x.shape[0];
     __pyx_t_7 = ((*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_address_hash_hex_no_0x.data) + __pyx_t_6)) ))) < 56);
     if (__pyx_t_7) {
 
-      /* "cchecksum/_checksum.pyx":44
+      /* "cchecksum/_checksum.pyx":45
  *         if address_hash_hex_no_0x[i] < 56:
  *             # '0' to '7' have ASCII values 48 to 55
  *             buffer[i + 2] = norm_address_mv[i]             # <<<<<<<<<<<<<<
  * 
  *         else:
  */
-      __Pyx_TraceLine(44,0,__PYX_ERR(0, 44, __pyx_L1_error))
+      __Pyx_TraceLine(45,0,__PYX_ERR(0, 45, __pyx_L1_error))
       __pyx_t_6 = __pyx_v_i;
-      if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_norm_address_mv.shape[0];
       (__pyx_v_buffer[(__pyx_v_i + 2)]) = (*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_norm_address_mv.data) + __pyx_t_6)) )));
 
-      /* "cchecksum/_checksum.pyx":42
+      /* "cchecksum/_checksum.pyx":43
  *     for i in range(40):
  * 
  *         if address_hash_hex_no_0x[i] < 56:             # <<<<<<<<<<<<<<
@@ -18212,27 +18210,26 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
       goto __pyx_L5;
     }
 
-    /* "cchecksum/_checksum.pyx":47
+    /* "cchecksum/_checksum.pyx":48
  * 
  *         else:
  *             address_char = norm_address_mv[i]             # <<<<<<<<<<<<<<
  *             # This checks if `address_char` falls in the ASCII range for lowercase hexadecimal
  *             # characters ('a' to 'f'), which correspond to ASCII values 97 to 102. If it does,
  */
-    __Pyx_TraceLine(47,0,__PYX_ERR(0, 47, __pyx_L1_error))
+    __Pyx_TraceLine(48,0,__PYX_ERR(0, 48, __pyx_L1_error))
     /*else*/ {
       __pyx_t_6 = __pyx_v_i;
-      if (__pyx_t_6 < 0) __pyx_t_6 += __pyx_v_norm_address_mv.shape[0];
       __pyx_v_address_char = (*((unsigned char const  *) ( /* dim=0 */ ((char *) (((unsigned char const  *) __pyx_v_norm_address_mv.data) + __pyx_t_6)) )));
 
-      /* "cchecksum/_checksum.pyx":51
+      /* "cchecksum/_checksum.pyx":52
  *             # characters ('a' to 'f'), which correspond to ASCII values 97 to 102. If it does,
  *             # the character is capitalized.
  *             buffer[i + 2] = address_char - 32 if 97 <= address_char <= 102 else address_char             # <<<<<<<<<<<<<<
  * 
- *     # NOTE: For some reason on some systems the buffer length is longer than 42 here, even though that should not be possible.
+ *     # It is faster to decode a buffer with a known size ie buffer[:42]
  */
-      __Pyx_TraceLine(51,0,__PYX_ERR(0, 51, __pyx_L1_error))
+      __Pyx_TraceLine(52,0,__PYX_ERR(0, 52, __pyx_L1_error))
       __pyx_t_7 = (97 <= __pyx_v_address_char);
       if (__pyx_t_7) {
         __pyx_t_7 = (__pyx_v_address_char <= 0x66);
@@ -18248,8 +18245,8 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   }
 
   /* "cchecksum/_checksum.pyx":55
- *     # NOTE: For some reason on some systems the buffer length is longer than 42 here, even though that should not be possible.
- *     #       Lucky for us, the first 42 characters are always correct. One day maybe I'll debug this.
+ * 
+ *     # It is faster to decode a buffer with a known size ie buffer[:42]
  *     return buffer[:42].decode('ascii')             # <<<<<<<<<<<<<<
  */
   __Pyx_TraceLine(55,0,__PYX_ERR(0, 55, __pyx_L1_error))
@@ -18260,8 +18257,8 @@ static PyObject *__pyx_pf_9cchecksum_9_checksum_cchecksum(CYTHON_UNUSED PyObject
   __pyx_t_3 = 0;
   goto __pyx_L0;
 
-  /* "cchecksum/_checksum.pyx":3
- * # cython: boundscheck=False
+  /* "cchecksum/_checksum.pyx":4
+ * # cython: wraparound=False
  * 
  * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
@@ -19309,7 +19306,7 @@ static int __Pyx_CreateStringTabAndInitStrings(void) {
     {&__pyx_n_s_cchecksum, __pyx_k_cchecksum, sizeof(__pyx_k_cchecksum), 0, 0, 1, 1},
     {&__pyx_n_s_cchecksum__checksum, __pyx_k_cchecksum__checksum, sizeof(__pyx_k_cchecksum__checksum), 0, 0, 1, 1},
     {&__pyx_kp_s_cchecksum__checksum_pyx, __pyx_k_cchecksum__checksum_pyx, sizeof(__pyx_k_cchecksum__checksum_pyx), 0, 0, 1, 0},
-    {&__pyx_kp_u_cchecksum_line_3, __pyx_k_cchecksum_line_3, sizeof(__pyx_k_cchecksum_line_3), 0, 1, 0, 0},
+    {&__pyx_kp_u_cchecksum_line_4, __pyx_k_cchecksum_line_4, sizeof(__pyx_k_cchecksum_line_4), 0, 1, 0, 0},
     {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1},
     {&__pyx_n_s_class_getitem, __pyx_k_class_getitem, sizeof(__pyx_k_class_getitem), 0, 0, 1, 1},
     {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
@@ -19395,7 +19392,7 @@ static int __Pyx_CreateStringTabAndInitStrings(void) {
 }
 /* #### Code section: cached_builtins ### */
 static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
-  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 40, __pyx_L1_error)
+  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 41, __pyx_L1_error)
   __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 83, __pyx_L1_error)
   __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(1, 83, __pyx_L1_error)
   __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 86, __pyx_L1_error)
@@ -19452,14 +19449,14 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_GOTREF(__pyx_tuple__8);
   __Pyx_GIVEREF(__pyx_tuple__8);
 
-  /* "cchecksum/_checksum.pyx":34
+  /* "cchecksum/_checksum.pyx":35
  *     # Create a buffer for our result
  *     # 2 for "0x" prefix and 40 for the address itself
  *     cdef unsigned char[42] buffer = b'0x' + bytearray(40)             # <<<<<<<<<<<<<<
  * 
  *     # Handle character casing based on the hash value
  */
-  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_int_40); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 34, __pyx_L1_error)
+  __pyx_tuple__10 = PyTuple_Pack(1, __pyx_int_40); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 35, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__10);
   __Pyx_GIVEREF(__pyx_tuple__10);
 
@@ -19564,17 +19561,17 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) {
   __Pyx_GIVEREF(__pyx_tuple__20);
   __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(1, 1, __pyx_L1_error)
 
-  /* "cchecksum/_checksum.pyx":3
- * # cython: boundscheck=False
+  /* "cchecksum/_checksum.pyx":4
+ * # cython: wraparound=False
  * 
  * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
-  __pyx_tuple__22 = PyTuple_Pack(6, __pyx_n_s_norm_address_no_0x, __pyx_n_s_address_hash_hex_no_0x, __pyx_n_s_norm_address_mv, __pyx_n_s_buffer, __pyx_n_s_i, __pyx_n_s_address_char); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __pyx_tuple__22 = PyTuple_Pack(6, __pyx_n_s_norm_address_no_0x, __pyx_n_s_address_hash_hex_no_0x, __pyx_n_s_norm_address_mv, __pyx_n_s_buffer, __pyx_n_s_i, __pyx_n_s_address_char); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_tuple__22);
   __Pyx_GIVEREF(__pyx_tuple__22);
-  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cchecksum__checksum_pyx, __pyx_n_s_cchecksum, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__22, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cchecksum__checksum_pyx, __pyx_n_s_cchecksum, 4, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_RefNannyFinishContext();
   return 0;
   __pyx_L1_error:;
@@ -20638,33 +20635,33 @@ if (!__Pyx_RefNanny) {
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_7) < 0) __PYX_ERR(1, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
 
-  /* "cchecksum/_checksum.pyx":3
- * # cython: boundscheck=False
+  /* "cchecksum/_checksum.pyx":4
+ * # cython: wraparound=False
  * 
  * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:             # <<<<<<<<<<<<<<
  *     """
  *     Computes the checksummed version of an Ethereum address.
  */
-  __Pyx_TraceLine(3,0,__PYX_ERR(0, 3, __pyx_L1_error))
-  __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3, __pyx_L1_error)
+  __Pyx_TraceLine(4,0,__PYX_ERR(0, 4, __pyx_L1_error))
+  __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_7);
-  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_return, __pyx_n_s_str) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
-  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9cchecksum_9_checksum_1cchecksum, 0, __pyx_n_s_cchecksum, NULL, __pyx_n_s_cchecksum__checksum, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_return, __pyx_n_s_str) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
+  __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_9cchecksum_9_checksum_1cchecksum, 0, __pyx_n_s_cchecksum, NULL, __pyx_n_s_cchecksum__checksum, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
   __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_7);
   __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
-  if (PyDict_SetItem(__pyx_d, __pyx_n_s_cchecksum, __pyx_t_4) < 0) __PYX_ERR(0, 3, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_d, __pyx_n_s_cchecksum, __pyx_t_4) < 0) __PYX_ERR(0, 4, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
 
   /* "cchecksum/_checksum.pyx":1
  * # cython: boundscheck=False             # <<<<<<<<<<<<<<
+ * # cython: wraparound=False
  * 
- * def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:
  */
   __Pyx_TraceLine(1,0,__PYX_ERR(0, 1, __pyx_L1_error))
   __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_GOTREF(__pyx_t_4);
-  if (PyDict_SetItem(__pyx_t_4, __pyx_kp_u_cchecksum_line_3, __pyx_kp_u_Computes_the_checksummed_versio) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
+  if (PyDict_SetItem(__pyx_t_4, __pyx_kp_u_cchecksum_line_4, __pyx_kp_u_Computes_the_checksummed_versio) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
   __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
   __Pyx_TraceReturn(Py_None, 0);

{cchecksum-0.0.10 → cchecksum-0.0.12}/cchecksum/_checksum.pyx

@@ -1,4 +1,5 @@
 # cython: boundscheck=False
+# cython: wraparound=False
 
 def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_no_0x) -> str:
     """
@@ -9,8 +10,8 @@ def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_
     Improvement Proposal 55 (EIP-55).
 
     Args:
-        norm_address_no_0x (str): The normalized Ethereum address without the '0x' prefix.
-        address_hash_hex_no_0x (bytes): The hash of the address, also without the '0x' prefix.
+        norm_address_no_0x: The normalized Ethereum address without the '0x' prefix.
+        address_hash_hex_no_0x: The hash of the address, also without the '0x' prefix.
 
     Returns:
         The checksummed Ethereum address with the '0x' prefix.
@@ -50,6 +51,5 @@ def cchecksum(str norm_address_no_0x, const unsigned char[::1] address_hash_hex_
             # the character is capitalized.
             buffer[i + 2] = address_char - 32 if 97 <= address_char <= 102 else address_char
 
-    # NOTE: For some reason on some systems the buffer length is longer than 42 here, even though that should not be possible.
-    #       Lucky for us, the first 42 characters are always correct. One day maybe I'll debug this.
+    # It is faster to decode a buffer with a known size ie buffer[:42]
     return buffer[:42].decode('ascii')

{cchecksum-0.0.10 → cchecksum-0.0.12}/cchecksum.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: cchecksum
-Version: 0.0.10
-Summary: A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
+Version: 0.0.12
+Summary: A ~4.5x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.
 Home-page: https://github.com/BobTheBuidler/cchecksum
 Author: BobTheBuidler
 Author-email: bobthebuidlerdefi@gmail.com

{cchecksum-0.0.10 → cchecksum-0.0.12}/setup.py

@@ -13,7 +13,7 @@ setup(
         "local_scheme": "no-local-version",
         "version_scheme": "python-simplified-semver",
     },
-    description="A ~2x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.",
+    description="A ~4.5x faster drop-in replacement for eth_utils.to_checksum_address. Raises the exact same Exceptions. Implemented in C.",
     author="BobTheBuidler",
     author_email="bobthebuidlerdefi@gmail.com",
     url="https://github.com/BobTheBuidler/cchecksum",

cchecksum-0.0.10/README.md

@@ -1,7 +0,0 @@
-## CChecksum
-
-CChecksum is a ~2x faster drop-in replacement for eth_utils.to_checksum_address, with the most cpu-intensive part implemented in c.
-
-Just `pip install cchecksum`, drop it in, and run your script with a substantial speed improvement.
-
-![image](https://github.com/user-attachments/assets/a2da6950-2759-42fa-8a56-7d7e095cd2ce)