publish: v1.1.2 - May stable

- Fix `Calculator`: `get_`, `set_`, `del_` api

Author: Pure-Peace

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peace-performance-python"
-version = "1.1.1"
+version = "1.1.2"
 authors = ["Pure-Peace <940857703@qq.com>"]
 edition = "2018"
 

peace_performance_python/__init__.py

@@ -7,7 +7,7 @@
 __author__ = 'Pure-Peace'
 __license__ = 'MIT'
 __copyright__ = 'Copyright 2021 Pure-Peace'
-__version__ = '1.1.1'
+__version__ = '1.1.2'
 
 from .objects import *
 from . import functions

pyproject.toml

@@ -10,7 +10,7 @@ requires = [
 
 [project]
 name = "peace-performance-python"
-version = "1.1.1"
+version = "1.1.2"
 description = "Rust binding for python. To calculate star ratings and performance points for all osu! gamemodes, and quickly parse Beatmap into python objects."
 keywords = "rust peace osu pp beatmap parse rosu-pp peace-performance"
 author = "PurePeace"

setup.py

@@ -19,7 +19,7 @@
 
 setup(
     name="peace-performance-python",
-    version="1.1.1",
+    version="1.1.2",
     description="Rust binding for python. To calculate star ratings and performance points for all osu! gamemodes, and quickly parse Beatmap into python objects.",
     long_description=open("README.md", encoding="utf-8").read(),
     long_description_content_type="text/markdown",

src/objects/calculator.rs

@@ -8,14 +8,36 @@ use pyo3::{
 use super::CalcResult;
 use crate::{methods::pp, objects::Beatmap, set_calculator};
 
-macro_rules! generate_func {
-    ({$($attr:ident: $type:ty),*}) => {
+macro_rules! create_py_methods {
+    ($for:ident, fn get_set_del() {$($attr:ident: $type:ty),*}, impl {$($others:tt)*}) => {
         paste::paste! {
-            $(
-                pub fn [<get_ $attr>](&self) -> $type { self.$attr }
-                pub fn [<set_ $attr>](&mut self, value: $type) { self.$attr = value; }
-                pub fn [<del_ $attr>](&mut self) { self.$attr = None; }
-            )*
+            #[pymethods] impl $for {
+                #[new]
+                #[args(data = "None", kwargs = "**")]
+                pub fn new(data: Option<&PyDict>, kwargs: Option<&PyDict>) -> PyResult<Self> {
+                    let mut slf = Self::default();
+                    if let Some(d) = data.or(kwargs) {
+                        Self::set_with_dict(&mut slf, d)?;
+                    }
+                    Ok(slf)
+                }
+
+                pub fn getattr<'a>(slf: &'a PyCell<Self>, attr: &PyAny) -> PyResult<&'a PyAny> {
+                    slf.as_ref().getattr(attr)
+                }
+
+                pub fn setattr<'a>(slf: &PyCell<Self>, attr: &PyAny, value: &PyAny) -> PyResult<()> {
+                    slf.as_ref().setattr(attr, value)
+                }
+
+                $(
+                    pub fn [<r#get_ $attr>](&self) -> $type { self.$attr }
+                    pub fn [<r#set_ $attr>](&mut self, value: $type) { self.$attr = value; }
+                    pub fn [<r#del_ $attr>](&mut self) { self.$attr = None; }
+                )*
+
+                $($others)*
+            }
         }
     };
 }
@@ -47,10 +69,9 @@ pub struct Calculator {
     pub score: Option<u32>,
 }
 crate::pyo3_py_protocol!(Calculator);
-
-#[pymethods]
-impl Calculator {
-    generate_func!({
+create_py_methods!(
+    Calculator,
+    fn get_set_del() {
         mode: Option<u8>,
         mods: Option<u32>,
         n50: Option<usize>,
@@ -62,125 +83,108 @@ impl Calculator {
         combo: Option<usize>,
         miss: Option<usize>,
         score: Option<u32>
-    });
-
-    #[new]
-    #[args(data = "None", kwargs = "**")]
-    pub fn new(data: Option<&PyDict>, kwargs: Option<&PyDict>) -> PyResult<Self> {
-        let mut slf = Self::default();
-        if let Some(d) = data.or(kwargs) {
-            Self::set_with_dict(&mut slf, d)?;
+    },
+    impl {
+        #[staticmethod]
+        pub fn new_empty() -> Self {
+            Self::default()
         }
-        Ok(slf)
-    }
-
-    #[staticmethod]
-    pub fn new_empty() -> Self {
-        Self::default()
-    }
-
-    #[inline(always)]
-    pub fn reset(&mut self) {
-        self.mode = None;
-        self.mods = None;
-        self.n50 = None;
-        self.n100 = None;
-        self.n300 = None;
-        self.katu = None;
-        self.acc = None;
-        self.passed_obj = None;
-        self.combo = None;
-        self.miss = None;
-        self.score = None;
-    }
 
-    #[inline(always)]
-    pub fn calculate_raw(&self, beatmap: &Beatmap) -> CalcResult {
-        CalcResult(self.calc(beatmap))
-    }
-
-    pub fn getattr<'a>(slf: &'a PyCell<Self>, attr: &PyAny) -> PyResult<&'a PyAny> {
-        slf.as_ref().getattr(attr)
-    }
+        #[inline(always)]
+        pub fn reset(&mut self) {
+            self.mode = None;
+            self.mods = None;
+            self.n50 = None;
+            self.n100 = None;
+            self.n300 = None;
+            self.katu = None;
+            self.acc = None;
+            self.passed_obj = None;
+            self.combo = None;
+            self.miss = None;
+            self.score = None;
+        }
 
-    pub fn setattr<'a>(slf: &PyCell<Self>, attr: &PyAny, value: &PyAny) -> PyResult<()> {
-        slf.as_ref().setattr(attr, value)
-    }
+        #[inline(always)]
+        pub fn calculate_raw(&self, beatmap: &Beatmap) -> CalcResult {
+            CalcResult(self.calc(beatmap))
+        }
 
-    #[inline(always)]
-    pub fn set_with_str(&mut self, attr: &str, value: &PyAny) -> PyResult<()> {
-        crate::set_with_py_str!(self, attr, value; {
-            mode,
-            mods,
-            n50,
-            n100,
-            n300,
-            katu,
-            acc,
-            passed_obj,
-            combo,
-            miss,
-            score
-        });
-        Ok(())
-    }
+        #[inline(always)]
+        pub fn set_with_str(&mut self, attr: &str, value: &PyAny) -> PyResult<()> {
+            crate::set_with_py_str!(self, attr, value; {
+                mode,
+                mods,
+                n50,
+                n100,
+                n300,
+                katu,
+                acc,
+                passed_obj,
+                combo,
+                miss,
+                score
+            });
+            Ok(())
+        }
 
-    #[inline(always)]
-    pub fn set_with_dict(&mut self, data: &PyDict) -> PyResult<()> {
-        for (k, v) in data.iter() {
-            self.set_with_str(&k.extract::<String>()?, v)?;
+        #[inline(always)]
+        pub fn set_with_dict(&mut self, data: &PyDict) -> PyResult<()> {
+            for (k, v) in data.iter() {
+                self.set_with_str(&k.extract::<String>()?, v)?;
+            }
+            Ok(())
         }
-        Ok(())
-    }
 
-    #[getter]
-    pub fn attrs(&self) -> String {
-        self.as_string()
-    }
+        #[getter]
+        pub fn attrs(&self) -> String {
+            self.as_string()
+        }
 
-    #[getter]
-    pub fn attrs_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> {
-        self.as_dict(py)
-    }
+        #[getter]
+        pub fn attrs_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> {
+            self.as_dict(py)
+        }
 
-    #[getter]
-    #[inline(always)]
-    pub fn as_string(&self) -> String {
-        format!(
-            "mode: {:?}, mods: {:?}, n50: {:?}, n100: {:?}, n300: {:?}, katu: {:?}, acc: {:?}, passed_obj: {:?}, combo: {:?}, miss: {:?}, score: {:?}",
-            self.mode,
-            self.mods,
-            self.n50,
-            self.n100,
-            self.n300,
-            self.katu,
-            self.acc,
-            self.passed_obj,
-            self.combo,
-            self.miss,
-            self.score,
-        )
-    }
+        #[getter]
+        #[inline(always)]
+        pub fn as_string(&self) -> String {
+            format!(
+                "mode: {:?}, mods: {:?}, n50: {:?}, n100: {:?}, n300: {:?}, katu: {:?}, acc: {:?}, passed_obj: {:?}, combo: {:?}, miss: {:?}, score: {:?}",
+                self.mode,
+                self.mods,
+                self.n50,
+                self.n100,
+                self.n300,
+                self.katu,
+                self.acc,
+                self.passed_obj,
+                self.combo,
+                self.miss,
+                self.score,
+            )
+        }
 
-    #[getter]
-    #[inline(always)]
-    pub fn as_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> {
-        let d = crate::pyo3_py_dict!(py, self; {
-            mode,
-            mods,
-            n50,
-            n100,
-            n300,
-            katu,
-            acc,
-            passed_obj,
-            combo,
-            miss,
-            score
-        });
-        Ok(d)
+        #[getter]
+        #[inline(always)]
+        pub fn as_dict<'a>(&self, py: Python<'a>) -> PyResult<&'a PyDict> {
+            let d = crate::pyo3_py_dict!(py, self; {
+                mode,
+                mods,
+                n50,
+                n100,
+                n300,
+                katu,
+                acc,
+                passed_obj,
+                combo,
+                miss,
+                score
+            });
+            Ok(d)
+        }
     }
-}
+);
 
 impl Calculator {
     #[inline(always)]

tests/test_bench_pp_calculates.py

@@ -51,3 +51,14 @@ def wrap(): Calculator({'acc': 98.8, 'miss': 3}).calculate(beatmap)
 def test_calculate_5(benchmark) -> CalcResult:
     def wrap(): Calculator(acc=98.8, miss=3).calculate(beatmap)
     benchmark(wrap)
+
+
+@pytest.mark.benchmark(group="bench-pp-calc")
+def test_calculate_6(benchmark) -> CalcResult:
+    def wrap():
+        # --
+        c = Calculator()
+        c.set_acc(98.8)
+        c.setattr('miss', 3)
+        c.calculate(beatmap)
+    benchmark(wrap)