fix + format

hugr-py/src/hugr/serialization/tys.py

@@ -97,6 +97,7 @@ class TypeParam(RootModel):
 # --------------- TypeArg ------------------
 # ------------------------------------------
 
+
 class TypeTypeArg(BaseModel):
     tya: Literal["Type"] = "Type"
     ty: "Type"
@@ -125,6 +126,7 @@ class ExtensionsArg(BaseModel):
     tya: Literal["Extensions"] = "Extensions"
     es: ExtensionSet
 
+
 class VariableArg(BaseModel):
     tya: Literal["Variable"] = "Variable"
     idx: int
@@ -135,7 +137,12 @@ class TypeArg(RootModel):
     """A type argument."""
 
     root: Annotated[
-        TypeTypeArg | BoundedNatArg | OpaqueArg | SequenceArg | ExtensionsArg | VariableArg,
+        TypeTypeArg
+        | BoundedNatArg
+        | OpaqueArg
+        | SequenceArg
+        | ExtensionsArg
+        | VariableArg,
         WrapValidator(_json_custom_error_validator),
     ] = Field(discriminator="tya")
 
@@ -266,8 +273,6 @@ def join(*bs: "TypeBound") -> "TypeBound":
         return res
 
 
-
-
 class Opaque(BaseModel):
     """An opaque Type that can be downcasted by the extensions that define it."""
 

hugr/src/extension.rs

@@ -544,16 +544,18 @@ mod test {
         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
             let vars = any::<HashSet<usize>>();
             let extensions = any::<HashSet<ExtensionId>>();
-            (vars,extensions).prop_map(|(vars,extensions)| {
-                let mut r = Self::new();
-                for v in vars {
-                    r.insert_type_var(v);
-                }
-                for e in extensions {
-                    r.insert(&e)
-                }
-                r
-            }).boxed()
+            (vars, extensions)
+                .prop_map(|(vars, extensions)| {
+                    let mut r = Self::new();
+                    for v in vars {
+                        r.insert_type_var(v);
+                    }
+                    for e in extensions {
+                        r.insert(&e)
+                    }
+                    r
+                })
+                .boxed()
         }
     }
 }

hugr/src/hugr/ident.rs

@@ -6,7 +6,7 @@ use regex::Regex;
 use smol_str::SmolStr;
 use thiserror::Error;
 
-static PATH_COMPONENT_REGEX_STR: &'static str = r"[\w--\d]\w*";
+static PATH_COMPONENT_REGEX_STR: &str = r"[\w--\d]\w*";
 lazy_static! {
     pub static ref PATH_REGEX_STR: String = format!(r"^{0}(\.{0})*$", PATH_COMPONENT_REGEX_STR);
     pub static ref PATH_REGEX: Regex = Regex::new(&self::PATH_REGEX_STR).unwrap();
@@ -102,8 +102,8 @@ mod test {
         type Parameters = ();
         type Strategy = BoxedStrategy<Self>;
         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
-            use proptest::collection::{vec, SizeRange};
-            let component_strategy = prop::string::string_regex(&PATH_COMPONENT_REGEX_STR)
+            use proptest::collection::vec;
+            let component_strategy = prop::string::string_regex(PATH_COMPONENT_REGEX_STR)
                 .unwrap()
                 .boxed();
             vec(component_strategy.clone(), 1..4)

hugr/src/hugr/serialize/test.rs

@@ -3,7 +3,6 @@ use crate::builder::{
     test::closed_dfg_root_hugr, Container, DFGBuilder, Dataflow, DataflowHugr,
     DataflowSubContainer, HugrBuilder, ModuleBuilder,
 };
-use proptest::prelude::*;
 use crate::extension::prelude::{BOOL_T, QB_T, USIZE_T};
 use crate::extension::simple_op::MakeRegisteredOp;
 use crate::extension::{EMPTY_REG, PRELUDE_REGISTRY};
@@ -26,6 +25,7 @@ use portgraph::LinkView;
 use portgraph::{
     multiportgraph::MultiPortGraph, Hierarchy, LinkMut, PortMut, PortView, UnmanagedDenseMap,
 };
+use proptest::prelude::*;
 use rstest::rstest;
 
 const NAT: Type = crate::extension::prelude::USIZE_T;

hugr/src/ops/module.rs

@@ -164,7 +164,9 @@ mod test {
         fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
             let name = proptest::string::string_regex(r".+").unwrap();
             let bound = any::<TypeBound>();
-            (name,bound).prop_map(|(name,bound)| Self::new(name,bound)).boxed()
+            (name, bound)
+                .prop_map(|(name, bound)| Self::new(name, bound))
+                .boxed()
         }
     }
 }

hugr/src/types.rs

@@ -449,18 +449,18 @@ pub(crate) fn check_typevar_decl(
 pub(crate) mod test {
     use super::*;
     use proptest::prelude::*;
-    use crate::extension::ExtensionSet;
+
     use crate::{extension::prelude::USIZE_T, ops::AliasDecl};
 
     use crate::types::TypeBound;
 
-    #[derive(Clone,Copy,Debug)]
+    #[derive(Clone, Copy, Debug)]
     pub struct TypeDepth(usize);
 
     impl TypeDepth {
         pub fn descend(&self) -> Self {
             if self.leaf() {
-                self.clone()
+                *self
             } else {
                 Self(self.0 - 1)
             }
@@ -483,53 +483,50 @@ pub(crate) mod test {
         }
     }
 
-
-    pub fn to_typerow(type_enums: impl IntoIterator<Item=Type>) -> TypeRow {
+    pub fn to_typerow(type_enums: impl IntoIterator<Item = Type>) -> TypeRow {
         type_enums.into_iter().collect_vec().into()
-
     }
 
     impl Arbitrary for super::TypeEnum {
         type Parameters = TypeDepth;
         type Strategy = BoxedStrategy<Self>;
         fn arbitrary_with(depth: Self::Parameters) -> Self::Strategy {
-            dbg!("Arbitrary<TypeEnum>: {}", depth);
-            prop_oneof! [
+            prop_oneof![
                 any_with::<CustomType>(depth).prop_map(Self::Extension),
                 any::<AliasDecl>().prop_map(Self::Alias),
-                any::<(usize,TypeBound)>().prop_map(|(us,tb)| Self::Variable(us,tb)),
+                any::<(usize, TypeBound)>().prop_map(|(us, tb)| Self::Variable(us, tb)),
                 any_with::<FunctionType>(depth).prop_map(|x| Self::Function(Box::new(x))),
                 any_with::<SumType>(depth).prop_map(Self::Sum),
-            ].boxed()
+            ]
+            .boxed()
         }
     }
 
     impl Arbitrary for super::SumType {
         type Parameters = TypeDepth;
         type Strategy = BoxedStrategy<Self>;
         fn arbitrary_with(depth: Self::Parameters) -> Self::Strategy {
-            use proptest::collection::{vec,SizeRange};
-            dbg!("Arbitrary<SumType>: {}", depth);
+            use proptest::collection::vec;
             let unit_strat = any::<u8>().prop_map(Self::new_unary);
             let general_strat = vec(any_with::<TypeRow>(depth), 0..3).prop_map(SumType::new);
-            let recurse_weight = if depth.leaf() { 0 } else { 1 };
-            prop_oneof![
-                1 => unit_strat,
-                recurse_weight => general_strat
-            ].boxed()
+            if depth.leaf() {
+                unit_strat.boxed()
+            } else {
+                general_strat.boxed()
+            }
         }
     }
 
     impl Arbitrary for super::Type {
         type Parameters = TypeDepth;
         type Strategy = BoxedStrategy<Self>;
         fn arbitrary_with(depth: Self::Parameters) -> Self::Strategy {
-            dbg!("Arbitrary<Type>: {}", depth);
-            any_with::<TypeEnum>(depth.descend()).prop_map(Self::new).boxed()
+            any_with::<TypeEnum>(depth.descend())
+                .prop_map(Self::new)
+                .boxed()
         }
     }
 
-
     #[test]
     fn construct() {
         let t: Type = Type::new_tuple(vec![
@@ -559,5 +556,4 @@ pub(crate) mod test {
         let pred_direct = SumType::Unit { size: 2 };
         assert_eq!(pred1, pred_direct.into())
     }
-
 }

hugr/src/types/custom.rs

@@ -150,7 +150,7 @@ mod test {
         type Parameters = crate::types::test::TypeDepth;
         type Strategy = BoxedStrategy<Self>;
         fn arbitrary_with(depth: Self::Parameters) -> Self::Strategy {
-            use proptest::collection::{size_range, vec};
+            use proptest::collection::vec;
             let extension = any::<ExtensionId>();
             let id = prop::string::string_regex(r".+")
                 .unwrap()
@@ -161,7 +161,6 @@ mod test {
                 vec(any_with::<TypeArg>(depth.descend()), 0..3).boxed()
             };
             let bound = any::<TypeBound>();
-            dbg!("Arbitrary<CustomType>: {}", depth);
             (id, args, extension, bound)
                 .prop_map(|(id, args, extension, bound)| Self::new(id, args, extension, bound))
                 .boxed()

hugr/src/types/signature.rs

@@ -253,7 +253,13 @@ mod test {
             let input = any_with::<TypeRow>(depth);
             let output = any_with::<TypeRow>(depth);
             let extension = any::<ExtensionSet>();
-            (input,output,extension).prop_map(|(input,output,extension_reqs)| FunctionType {input,output,extension_reqs}).boxed()
+            (input, output, extension)
+                .prop_map(|(input, output, extension_reqs)| FunctionType {
+                    input,
+                    output,
+                    extension_reqs,
+                })
+                .boxed()
         }
     }
 }