@@ -96,18 +96,18 @@ def test_is_monotonic(self, numeric_indexing_engine_type_and_dtype):
96
96
arr = np .array ([1 ] * num + [2 ] * num + [3 ] * num , dtype = dtype )
97
97
98
98
# monotonic increasing
99
- engine = engine_type (lambda : arr , len ( arr ) )
99
+ engine = engine_type (arr )
100
100
assert engine .is_monotonic_increasing is True
101
101
assert engine .is_monotonic_decreasing is False
102
102
103
103
# monotonic decreasing
104
- engine = engine_type (lambda : arr [::- 1 ], len ( arr ) )
104
+ engine = engine_type (arr [::- 1 ])
105
105
assert engine .is_monotonic_increasing is False
106
106
assert engine .is_monotonic_decreasing is True
107
107
108
108
# neither monotonic increasing or decreasing
109
109
arr = np .array ([1 ] * num + [2 ] * num + [1 ] * num , dtype = dtype )
110
- engine = engine_type (lambda : arr [::- 1 ], len ( arr ) )
110
+ engine = engine_type (arr [::- 1 ])
111
111
assert engine .is_monotonic_increasing is False
112
112
assert engine .is_monotonic_decreasing is False
113
113
@@ -116,31 +116,31 @@ def test_is_unique(self, numeric_indexing_engine_type_and_dtype):
116
116
117
117
# unique
118
118
arr = np .array ([1 , 3 , 2 ], dtype = dtype )
119
- engine = engine_type (lambda : arr , len ( arr ) )
119
+ engine = engine_type (arr )
120
120
assert engine .is_unique is True
121
121
122
122
# not unique
123
123
arr = np .array ([1 , 2 , 1 ], dtype = dtype )
124
- engine = engine_type (lambda : arr , len ( arr ) )
124
+ engine = engine_type (arr )
125
125
assert engine .is_unique is False
126
126
127
127
def test_get_loc (self , numeric_indexing_engine_type_and_dtype ):
128
128
engine_type , dtype = numeric_indexing_engine_type_and_dtype
129
129
130
130
# unique
131
131
arr = np .array ([1 , 2 , 3 ], dtype = dtype )
132
- engine = engine_type (lambda : arr , len ( arr ) )
132
+ engine = engine_type (arr )
133
133
assert engine .get_loc (2 ) == 1
134
134
135
135
# monotonic
136
136
num = 1000
137
137
arr = np .array ([1 ] * num + [2 ] * num + [3 ] * num , dtype = dtype )
138
- engine = engine_type (lambda : arr , len ( arr ) )
138
+ engine = engine_type (arr )
139
139
assert engine .get_loc (2 ) == slice (1000 , 2000 )
140
140
141
141
# not monotonic
142
142
arr = np .array ([1 , 2 , 3 ] * num , dtype = dtype )
143
- engine = engine_type (lambda : arr , len ( arr ) )
143
+ engine = engine_type (arr )
144
144
expected = np .array ([False , True , False ] * num , dtype = bool )
145
145
result = engine .get_loc (2 )
146
146
assert (result == expected ).all ()
@@ -149,7 +149,7 @@ def test_get_backfill_indexer(self, numeric_indexing_engine_type_and_dtype):
149
149
engine_type , dtype = numeric_indexing_engine_type_and_dtype
150
150
151
151
arr = np .array ([1 , 5 , 10 ], dtype = dtype )
152
- engine = engine_type (lambda : arr , len ( arr ) )
152
+ engine = engine_type (arr )
153
153
154
154
new = np .arange (12 , dtype = dtype )
155
155
result = engine .get_backfill_indexer (new )
@@ -161,7 +161,7 @@ def test_get_pad_indexer(self, numeric_indexing_engine_type_and_dtype):
161
161
engine_type , dtype = numeric_indexing_engine_type_and_dtype
162
162
163
163
arr = np .array ([1 , 5 , 10 ], dtype = dtype )
164
- engine = engine_type (lambda : arr , len ( arr ) )
164
+ engine = engine_type (arr )
165
165
166
166
new = np .arange (12 , dtype = dtype )
167
167
result = engine .get_pad_indexer (new )
@@ -181,54 +181,54 @@ def test_is_monotonic(self):
181
181
arr = np .array (["a" ] * num + ["a" ] * num + ["c" ] * num , dtype = self .dtype )
182
182
183
183
# monotonic increasing
184
- engine = self .engine_type (lambda : arr , len ( arr ) )
184
+ engine = self .engine_type (arr )
185
185
assert engine .is_monotonic_increasing is True
186
186
assert engine .is_monotonic_decreasing is False
187
187
188
188
# monotonic decreasing
189
- engine = self .engine_type (lambda : arr [::- 1 ], len ( arr ) )
189
+ engine = self .engine_type (arr [::- 1 ])
190
190
assert engine .is_monotonic_increasing is False
191
191
assert engine .is_monotonic_decreasing is True
192
192
193
193
# neither monotonic increasing or decreasing
194
194
arr = np .array (["a" ] * num + ["b" ] * num + ["a" ] * num , dtype = self .dtype )
195
- engine = self .engine_type (lambda : arr [::- 1 ], len ( arr ) )
195
+ engine = self .engine_type (arr [::- 1 ])
196
196
assert engine .is_monotonic_increasing is False
197
197
assert engine .is_monotonic_decreasing is False
198
198
199
199
def test_is_unique (self ):
200
200
# unique
201
201
arr = np .array (self .values , dtype = self .dtype )
202
- engine = self .engine_type (lambda : arr , len ( arr ) )
202
+ engine = self .engine_type (arr )
203
203
assert engine .is_unique is True
204
204
205
205
# not unique
206
206
arr = np .array (["a" , "b" , "a" ], dtype = self .dtype )
207
- engine = self .engine_type (lambda : arr , len ( arr ) )
207
+ engine = self .engine_type (arr )
208
208
assert engine .is_unique is False
209
209
210
210
def test_get_loc (self ):
211
211
# unique
212
212
arr = np .array (self .values , dtype = self .dtype )
213
- engine = self .engine_type (lambda : arr , len ( arr ) )
213
+ engine = self .engine_type (arr )
214
214
assert engine .get_loc ("b" ) == 1
215
215
216
216
# monotonic
217
217
num = 1000
218
218
arr = np .array (["a" ] * num + ["b" ] * num + ["c" ] * num , dtype = self .dtype )
219
- engine = self .engine_type (lambda : arr , len ( arr ) )
219
+ engine = self .engine_type (arr )
220
220
assert engine .get_loc ("b" ) == slice (1000 , 2000 )
221
221
222
222
# not monotonic
223
223
arr = np .array (self .values * num , dtype = self .dtype )
224
- engine = self .engine_type (lambda : arr , len ( arr ) )
224
+ engine = self .engine_type (arr )
225
225
expected = np .array ([False , True , False ] * num , dtype = bool )
226
226
result = engine .get_loc ("b" )
227
227
assert (result == expected ).all ()
228
228
229
229
def test_get_backfill_indexer (self ):
230
230
arr = np .array (["a" , "e" , "j" ], dtype = self .dtype )
231
- engine = self .engine_type (lambda : arr , len ( arr ) )
231
+ engine = self .engine_type (arr )
232
232
233
233
new = np .array (list ("abcdefghij" ), dtype = self .dtype )
234
234
result = engine .get_backfill_indexer (new )
@@ -238,7 +238,7 @@ def test_get_backfill_indexer(self):
238
238
239
239
def test_get_pad_indexer (self ):
240
240
arr = np .array (["a" , "e" , "j" ], dtype = self .dtype )
241
- engine = self .engine_type (lambda : arr , len ( arr ) )
241
+ engine = self .engine_type (arr )
242
242
243
243
new = np .array (list ("abcdefghij" ), dtype = self .dtype )
244
244
result = engine .get_pad_indexer (new )
0 commit comments