-
-
Save isidentical/099da256f2a46d13cef8570e839a2cea to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| tmdata.create_report | |
| cairo.SolidPattern | |
| Perm(0, 7, 13)(1, 12, 9)(2, 8, 4)(5, 11, 19)(6, 18, 14) | |
| python | |
| glVertex3f | |
| p.drawRect | |
| self.ckDefaultToTime | |
| Comment | |
| glColor3ub | |
| RGBA | |
| deps_list | |
| uproot_methods.classes.TVector3.TVector3 | |
| select | |
| state._wrap_check | |
| wigner_9j | |
| r.zremrangebyrank | |
| salt_run_cli.run | |
| wcs.array_index_to_world_values | |
| self.design[..., start:end].transpose | |
| res.smoothed_state_cov.transpose | |
| np.arange(6, dtype='float').reshape | |
| execute_Run_intern | |
| XmlMappedEnumMember | |
| command.add_argument | |
| Soil | |
| _expand_paths | |
| recursive_rm | |
| QGraphicsProxyWidget.boundingRect(self).adjusted | |
| ignore_patterns | |
| self.runScript | |
| path_to_url.create_path | |
| socket_c | |
| params | |
| _ip.run_cell_magic | |
| address_type | |
| set_mock.assert_called_once_with | |
| filters.RegExpFilter | |
| salt.modules.reg.read_value | |
| xapi.vcpu_pin | |
| CourseLocator | |
| p.getLineDash_count_phase_ | |
| Foundation.NSMutableDictionary.dictionaryWithObjectsAndKeys_ | |
| encipher_substitution | |
| self._env_and_runner | |
| np.arange(5 * 6 * 7).reshape | |
| UninstallationError.create_path | |
| SafeFileCache.create_path | |
| SimplifiedObjectInfo | |
| fs._instances[0].node._record.add_new | |
| self.partition_utils._mkfs | |
| self.locales.getLocale | |
| groupPath.arcTo | |
| self.stats.log_request | |
| np.array(list(range(3 * 4 * 5))).reshape | |
| flex_binary_moment | |
| GaussianInverse | |
| Perm(0, 4, 3) | |
| demonstrate_256_colors | |
| CoreFoundation.CFStreamCreatePairWithSocketToHost | |
| verify_signature | |
| w.sip_pix2foc | |
| Cell.from_face_pos_level | |
| django_user_model._default_manager.create_superuser | |
| Config.setdefault | |
| configparser.DuplicateOptionError | |
| BITBUCKET.get_pipeline | |
| _CodecOptions | |
| mytype3.set_fields | |
| repo.get_store().should_receive('put').once().with_args | |
| self.mock_layer1.list_jobs.assert_called_with | |
| res.smoothed_state_autocovariance(-1).transpose | |
| ai5.hasSameArgs | |
| Foundation.NSOrderedSet.orderedSetWithObjects_ | |
| hp.lognormal | |
| fourfv | |
| Perm(0, 7, 13)(1, 12, 9) | |
| Mixed | |
| self.driver.ex_add_hdd | |
| _DateMask | |
| mymodule.my_function | |
| QColor | |
| axle.set_color | |
| result.foo.assert_called_once_with | |
| y_zero_point.reshape | |
| img.SetMaskColour | |
| ModuleScope | |
| console.color_print | |
| np.arange(2 * 3 * 4, dtype=dtype).reshape | |
| delegate_to_executor | |
| t.setFillColorRGB | |
| truesecret.store | |
| m.vectorized_func | |
| cephes.mathieu_cem | |
| Wife | |
| self.tx.classic_email_send | |
| log_softmax_2d_expected.reshape | |
| libcloud_dns.zone_present | |
| self.gwt | |
| ellipsePath.arcTo | |
| g.add_units | |
| Dataclass1 | |
| smart_open.s3.open | |
| d21v | |
| methodcaller | |
| host_object.EnterMaintenanceMode_Task | |
| Hacker | |
| urwid.Divider | |
| RegexOption | |
| np.repeat(b'spam', 24).reshape | |
| validator | |
| Perm(0, 1, 7, 8, 3) | |
| self._ribbon.GetArtProvider().GetColourScheme | |
| dbapi2.Date | |
| self.TargetOne().dispatch.event_three | |
| settings.set | |
| call().__exit__ | |
| ax.text | |
| Network | |
| np.mgrid[0:10, 0:10, 0:1].reshape | |
| gy.transpose | |
| c.create | |
| nar.randint | |
| self.api.create_stack | |
| q.edit_cell | |
| tensor_CHW.transpose | |
| _fssys | |
| redis.zrange | |
| self.baremetal_mock.node.set_boot_device.assert_called_once_with | |
| np.linspace(10, 20, 1000).reshape | |
| self.check_raises | |
| actual.transpose | |
| self.A.find | |
| deviation | |
| mock_get_action.return_value.assert_called_once_with | |
| info.add | |
| gdb_init | |
| dog.histogram | |
| pack | |
| xml.etree.ElementTree.XMLParser('tag', None, None).doctype | |
| np.arange(2).reshape | |
| structured_objects | |
| ctxI.set_source_rgba | |
| self.jalali_to_jd | |
| y | |
| choices.convert | |
| sp1.translate | |
| driver.Date | |
| session.install | |
| self.checkJoin | |
| Unpickleable | |
| super(RemoteTraversal, self).__init__ | |
| self.create_image | |
| self.page.get_translations().only | |
| monty_pow | |
| piePath.arcTo | |
| wx.Image.HSVValue | |
| converted.select | |
| _overlapped.CreateEvent | |
| request.requestReceived | |
| validate_ip | |
| _inplacevar_.assert_called_once_with | |
| self._try_failover_combos | |
| XmeansTestTemplates.random_state | |
| GumbelDistribution | |
| GLfloat * 3 | |
| np.arange(5).repeat(2).reshape | |
| stats.power_under_cph | |
| Perm(0, 1, 2, 3) | |
| cephes.btdtrib | |
| self.call | |
| self.monkey_patch_argv | |
| Environment | |
| self.use_edns | |
| stats.nbinom.logpmf | |
| SomeEnum | |
| call.add_rel | |
| call.meth | |
| form.set | |
| metrics.sensor | |
| r.insert | |
| np.arange(105).reshape | |
| bucket.append_object | |
| rect.update | |
| format_meter | |
| r.zrevrangebyscore | |
| span_log.warning.assert_called_once_with | |
| self.cl.sizes | |
| Perm(0, 6, 17, 19, 9) | |
| a_func | |
| yAxis.setPosition | |
| np.arange(100).reshape | |
| query_inst.where | |
| a.byteswap | |
| dt.datetime | |
| RESULT_TEMPLATE.format | |
| A1 | |
| m.add_transition | |
| api_general_client.reportTCResult | |
| arange(27).reshape | |
| cephes.bdtrin | |
| annealing | |
| self._single_implementation_compiler | |
| r.terms_within | |
| shapely.geometry.box | |
| Quartz.CGPostScrollWheelEvent | |
| MoveEvent | |
| otConverters.Char64 | |
| convert_to_datetime | |
| Perm(1, 4, 5)(2, 9, 10) | |
| rng.binomial | |
| mj | |
| load_name_range | |
| self.client._url | |
| obj.skip_return_val | |
| self.config.getboolean | |
| grafana_iface.create_user | |
| api._put | |
| mod._get_prediction_index | |
| cf.set | |
| type.Overloaded[str] | |
| Envelope | |
| self.responses.put | |
| np.arange(1.0, 4 * 8 * 7 + 1).reshape | |
| gradient.add_color_stop_rgba | |
| _OPERATION | |
| Foundation.NSMutableArray.arrayWithObjects_ | |
| Chunk.__repr__(self).replace | |
| self.matchKeyword | |
| tree.set_range | |
| cj.clear | |
| Foundation.NSAffineTransformStruct | |
| date.strip().replace | |
| query1.where | |
| SphinxDocstring.re_property_type_raw.replace | |
| kw_func | |
| numpy.linspace | |
| self.checkerboard.blit | |
| debug.Debug | |
| canvas.line | |
| relative_days | |
| Perm(0, 8, 15)(1, 12, 16)(2, 18, 10)(3, 19, 5)(4, 13, 14) | |
| SupervisorTransport | |
| session.XenAPISession | |
| config.set_multivar | |
| address.USAddress | |
| function_3_args | |
| Graph.Recent_Degree | |
| Epoch.get_doy | |
| np.array([[np.nan] * 2]).reshape | |
| svgwrite.rgb | |
| Crop | |
| PythonExpr | |
| path.join | |
| np.arange(10.0 * 11.0 * 12.0).reshape | |
| slice | |
| ga_observer | |
| msgBoxFunc | |
| o.dimshuffle | |
| data.reshape | |
| fut | |
| mock_set.assert_any_call | |
| stdlib_pkgs.create_path | |
| dns.tsig.Key | |
| t.suggest_float | |
| getout | |
| Perm(0, 3, 9)(1, 8, 14)(2, 13, 5)(6, 12, 15) | |
| projenv.BuildSources | |
| mock_get_si.assert_called_once_with | |
| Perm(0, 3, 9)(1, 8, 14)(2, 13, 5)(6, 12, 15)(7, 19, 10) | |
| urwid.Edit | |
| iam.ARN | |
| xs.date | |
| envmodule.__utils__['reg.delete_value'].assert_called_with | |
| lb.lookup1 | |
| self.instance.save | |
| color.getHue_saturation_brightness_alpha_ | |
| d02v | |
| self.output_uri.replace | |
| smart_open.gcs.open | |
| P | |
| td.api.add_user | |
| Key | |
| hyperopt.hp.uniform | |
| self._textwidget.tag_add | |
| RLPType3 | |
| c.delete_container | |
| self.plasma_store_ctx.__exit__ | |
| self.cli_config.set_value | |
| update.add | |
| self.config_manager.lookup_rest_method | |
| add_or_replace_parameter | |
| Point | |
| mock_do_mount.assert_called_once_with | |
| addtag | |
| GL.glRotatef | |
| gen_ol(impl5) | |
| mock_val.assert_called_once_with | |
| Style | |
| SlashSeparatedCourseKey | |
| r.sadd | |
| ssl.SSLError | |
| r.baseui.setconfig | |
| chacha.decrypt | |
| transaction.insert.assert_called_once_with | |
| glScalef | |
| tz | |
| httpbin | |
| dwg.viewbox | |
| client.service.ConvertSpeed | |
| KafkaProtocol._encode_message_header | |
| r.delete | |
| self.__owm.weather_at_places_in_bbox | |
| mock_add_disk.assert_called_once_with | |
| hyp1f1 | |
| namedtuple('partition', 'device mountpoint fstype, opts') | |
| self.templar._lookup | |
| grafana_iface.update_team | |
| twilio_notify.send_sms | |
| QMessageBox.warning | |
| np.array(list(range(24))).reshape | |
| full_url.replace | |
| BITBUCKET.get_issue | |
| envmodule.__utils__['reg.set_value'].assert_called_with | |
| DNSRRCountField | |
| mysql.SET | |
| line.replace | |
| colbars_point75.reshape | |
| misc.clamp | |
| gl.glColor | |
| Date | |
| utc | |
| c.put_container | |
| pat.match('a').group | |
| r.srem | |
| qs1.union(qs1).values_list | |
| self.api.getTestPlanCustomFieldDesignValue | |
| self._do_test | |
| Perm(0, 11, 8)(1, 7, 3)(4, 6, 12)(5, 17, 13)(9, 10, 18) | |
| rc.set | |
| LEBitField | |
| self._notify_trait | |
| np.arange(2 * 7 * 5, dtype=np.float64).reshape | |
| self._test_compiler | |
| self._warning_filters.__exit__ | |
| FlagsField | |
| opj | |
| bigquery.ScalarQueryParameter | |
| CreateManagedType | |
| better_float_of | |
| Quartz.CGColorCreateGenericCMYK | |
| ilo.configure_network | |
| smbConfig.set | |
| img.sketch | |
| Perm(0, 8, 10)(1, 7, 6)(2, 11, 5) | |
| t.dungettext | |
| self.filter.method | |
| libcloud_dns.record_absent | |
| ProcessCommunicationEvent | |
| trace.__exit__ | |
| out[0].reshape | |
| '{0:d}x{1:d}+{2:d}+{3:d}'.format | |
| conn.describe_activity_type.when.called_with | |
| reconstruct | |
| self.table.set_cell | |
| h5.VirtualSource | |
| ExceptionReporter | |
| helper | |
| inst | |
| self._add_build | |
| conn.put_key_policy.when.called_with | |
| rod.set_color | |
| td.api.bulk_import_upload_part.assert_called_with | |
| np.ones(27).reshape | |
| wx.GenericMessageDialog | |
| client | |
| self._hyper3.SetColours | |
| kafka.util.relative_unpack | |
| self._test_parser | |
| Perm(0, 16, 7) | |
| randMatrix | |
| javabridge.get_static_field | |
| changed_notebooks | |
| ServiceMaker | |
| func['A'][0] | |
| np.array([1.5, 2.5, 3.5], dtype=np.float32).reshape | |
| _vector_from_args | |
| hp_uniform | |
| peer.Peer | |
| self.rg.gamma | |
| g.all_st_mincuts | |
| _d.__wrapped__ | |
| DiskArbitration.DADissenterCreate | |
| mock.should_receive('put').once().with_args | |
| api_action | |
| app.add_object_type | |
| self.parse_string | |
| TestPickle3 | |
| grids_available | |
| sm.distributions.zinegbin.ppf | |
| client.document | |
| np.random.RandomState(0).rand | |
| lifecycle.add_rule | |
| var.callString1 | |
| BITBUCKET.get_pipeline_step_log | |
| parse_requirements.create_path | |
| CoreFoundation.CFNumberCompare | |
| colors.Color | |
| np.arange(80, dtype=np.double).reshape | |
| comps[4].replace | |
| topgrad.dimshuffle | |
| Point3D | |
| format_string.format | |
| y_hat_pca.transpose | |
| sc.roots_jacobi | |
| self.__smbConfig.set | |
| check_programs | |
| iter_nmap_range | |
| self._header_win.SetSize | |
| container.delete_blobs | |
| AudioResampler | |
| self._get_expected_args_create | |
| bucket.copy_key | |
| worksheet.set_column | |
| cephes.btdtr | |
| b.translate | |
| img.ConvertToMono | |
| UninstallPathSet.create_path | |
| redis.zremrangebylex | |
| np.array([2, 3, 6, 7, 10, 11], dtype=np.float32).reshape | |
| self.path | |
| np.pv | |
| target_mapping.permute | |
| contains | |
| np.arange(36).reshape | |
| SpeFormat | |
| np.linspace(10, 20, 5 * 4 * 3).reshape | |
| getattr | |
| self.api.getTestCaseCustomFieldExecutionValue | |
| cnn.xid | |
| warn_deprecation | |
| rsa.rsa_recover_prime_factors | |
| strength.create | |
| patch_module | |
| array.c | |
| r.zlexcount | |
| c_ast.TypeDecl | |
| inp.dimshuffle | |
| strutils.split_path | |
| PipError.create_path | |
| self.hTabLayout.setContentsMargins | |
| beam.apply_load | |
| self.t1.reshape | |
| Table | |
| BeniniDistribution | |
| uwsgi.cache_update | |
| T.get_types | |
| cull_cache.set | |
| digits | |
| client_context.require_version_max | |
| RaisedCosine | |
| environ.__utils__['reg.set_value'].assert_called_with | |
| d.__exit__ | |
| catcher.__exit__ | |
| numpy.frombuffer(WORDS, 'uint16').reshape | |
| self.petest | |
| Cycle(1, 2) | |
| p.add_color_stop_rgba | |
| cache.add | |
| Color.hsv | |
| lookup_property | |
| df._set_value | |
| netscaler.vserver_add | |
| Perm(0, 8, 15) | |
| self.gridLayout_4.setContentsMargins | |
| nx.complete_multipartite_graph | |
| BaseWindow.array_from_text_rc | |
| self.dropna | |
| xp.arange | |
| client.alter_retention_policy.assert_called_once_with | |
| default_fn | |
| client.fput_object | |
| Png | |
| numpy.arange(1000).reshape | |
| Color.Color | |
| nx.planted_partition_graph | |
| pxi | |
| f.check | |
| self.driver1._get_standard_range_str | |
| monit.Monit | |
| graph.msgin | |
| cls.fmtstr.format | |
| np.array(img).transpose | |
| td.history | |
| pqos.execute_command | |
| (Q @ D @ Q.transpose(0, 2, 1)).transpose | |
| self._assert_restricted | |
| MapKit.MKMapRectMake | |
| PretrainedInfo | |
| self.addMethods | |
| tf.flags.DEFINE_string | |
| self.templateCfTreeTotalNumberPoints | |
| _H5PY_VERSION_CLS | |
| get_account_event | |
| __salt__['file.sed'] | |
| add_entry_point | |
| fig4.add_subplot | |
| c._validate_scalar_type | |
| EarthLocation | |
| graph_from_nodes | |
| TestProcess | |
| arange(12).reshape | |
| self.rg.integers | |
| features.withColumn('__mahalanobis', pudf_mult('__array_scaled')).drop | |
| filter_name.replace | |
| self.config.deploy_cert | |
| get_plotting_function | |
| FoodManager | |
| gl.glClearColor | |
| openstack_config.delete | |
| stem.util.enum.UppercaseEnum | |
| _register_lltd_specific_class | |
| AppKit.NSColor.redColor().getRed_green_blue_alpha_ | |
| find_field | |
| np.array(coreml_out).transpose | |
| VideoFormat | |
| uri_as_string.replace | |
| graph.createReference | |
| Duration | |
| win32structures.RECT | |
| tensor.alloc(x, 3, 2).dimshuffle | |
| c.get_auth | |
| BoundedParetoDistribution | |
| config.add_subscriber_predicate | |
| x_i.transpose | |
| x.index | |
| numpy.random.uniform(-1, 1, 24).reshape | |
| group.authorize | |
| EarthLocation.from_geodetic | |
| m1.scale | |
| table.add_cell | |
| imageio.formats.sort | |
| commands.FileModifyCommand | |
| self.formlayout.setContentsMargins | |
| none_of | |
| self.SetScrollbars | |
| confint.transpose | |
| tab1hbox.setContentsMargins | |
| distribution.create_exponential | |
| redis.xgroup_delconsumer | |
| self.wrapper.__exit__ | |
| find_obj | |
| feedgenerator.Enclosure | |
| get_supported.create_path | |
| conn.register_activity_type.when.called_with | |
| self._run_each_parallel_throughput_test | |
| fnct | |
| mock.foo | |
| r.hset | |
| r.ltrim | |
| Graph.Tree | |
| ProcessTerminated | |
| PluginEntry | |
| r.zrevrange | |
| pub.execute | |
| mtransforms.Affine2D.from_values | |
| self.rs.uniform | |
| deprecated_renamed_argument | |
| I1 | |
| self.SetMargins | |
| boto.exception.StorageCreateError | |
| cairo.PDFSurface | |
| np.arange(6.0).reshape | |
| a.set_value | |
| Bound(Normal, upper=6) | |
| Observer | |
| _scal_elemwise_with_nfunc | |
| win32.CreateEvent | |
| np.array([4, 5, 6], dtype=np.uint8).reshape | |
| vi_pos_end_short | |
| every().second.do(make_mock_job(name='job3')).tag | |
| dateimport | |
| self._test_environment_variable | |
| self.instance.create_review | |
| self.get_vscan_mock_object | |
| u.dimshuffle | |
| widget.value_from_datadict | |
| ipv6.option | |
| AssetLocation | |
| numpy.random.randint(low, high, size=33 * 31 * 3, dtype=dtype).reshape | |
| self.s0.distance.reshape | |
| tt.eye(self.dim).dimshuffle | |
| w.all_pix2world | |
| ProgressBar | |
| self.iteratable.cell_value | |
| cairo.RadialGradient | |
| Constant | |
| test_datetime | |
| cv.KalmanFilter | |
| self.api._put | |
| self._assert_installs_python3_on_py3 | |
| authorizer.add_user | |
| stats.gamma.rvs | |
| _make_entity | |
| cephes.pro_cv | |
| self.translations.ldnpgettext | |
| model | |
| helpers.to_lower | |
| td.api.change_database.assert_called_with | |
| fmt.set_option | |
| FutureImportation | |
| self.check_token | |
| QTime | |
| BITBUCKET.delete_branch_restriction | |
| libcloud_compute.create_image | |
| github3.issue | |
| service.Application | |
| _extract_domain_type_and_bounds | |
| self._test_update_quota | |
| ctxI.rectangle | |
| redis.zrevrange | |
| val.replace | |
| self.ptest | |
| PreviousBuildDirError.create_path | |
| self.srv.set_x509_certificates | |
| snoop.assert_total | |
| statement.rename_column_references | |
| _Range | |
| InstallRequirement.create_path | |
| self.repo.git | |
| pendulum_datetime.pendulum.datetime | |
| np.arange(24.0).reshape | |
| random_state.uniform | |
| output.get('source').replace | |
| Perm(0, 6, 8) | |
| sm.distributions.zinegbin.pmf | |
| Ellipse | |
| editor.set_menu_context | |
| f_wrapped | |
| dut.api('routemaps').create | |
| arange(2).reshape | |
| _buildOid | |
| self.service_connection.put_record | |
| self._test_calc_chunk_size | |
| deriv(tt.batched_dot(z, w) + b).dimshuffle | |
| np.arange(8.0).reshape | |
| self.good_include.matches | |
| pg.QtGui.QGraphicsEllipseItem | |
| np.arange(2 * 1 * 5).reshape | |
| api_config.Namespace | |
| namedtuple('snetio', 'bytes_sent bytes_recv packets_sent packets_recv errin errout dropin dropout') | |
| stats.betaprime.cdf | |
| circle_perimeter_aa | |
| self._test_build_rekey_key_pair_batch_item | |
| self.date_type | |
| g.wasGeneratedBy | |
| EXMLTestResult | |
| dns.Record_SRV | |
| datetime.set | |
| special.obl_cv_seq | |
| arange(1, 31).reshape | |
| m.parse_options | |
| PluginLoader | |
| Perm(7)(0, 5, 2) | |
| self.page.evaluate | |
| ResponseStartLine | |
| self.matches | |
| CoreFoundation.CFPreferencesGetAppBooleanValue | |
| ctx.__exit__ | |
| models.Gaussian2D | |
| validate_token | |
| self.bad_match.format | |
| good.add_transition | |
| genesis.bootstrap | |
| impl.createDocument | |
| decorated_class | |
| s.triple | |
| popts.PowerOnOpts().ibmi_netboot_params | |
| self._test_brick_get_connector_properties | |
| BITBUCKET.delete_issue | |
| row_3.set_cell | |
| CategorySeriesData | |
| SetBackgroundTag | |
| psycopg2.Date | |
| p_el_path.replace('.', '').replace | |
| Less | |
| hyp2f1 | |
| check_unary_op | |
| b.iter | |
| self.run | |
| cache.put | |
| a.setm | |
| persist | |
| cloud._save_password_in_keyring | |
| self.monitor.format_row | |
| pd.option_context | |
| CHECKPOINT_SCRIPT_FORMAT.format | |
| self.cqlsh_runner.__exit__ | |
| np.arange(192000.0).reshape | |
| luigi.scheduler.RetryPolicy | |
| dataset.expect_column_mean_to_be_between | |
| hostname.replace | |
| cairo.PSSurface | |
| observer.get_notifier | |
| pm.Lognormal | |
| ObjectIdentity | |
| arange(24).reshape | |
| self.spreadsheet.add_worksheet | |
| hp.Prod | |
| self.template.update | |
| conn.start_workflow_execution | |
| watermelon.tags.add | |
| special.lpmn | |
| urlunparse(parsed).replace | |
| self.calendar.set_today | |
| mock | |
| empty_msgid_store.add_legacy_msgid_and_symbol | |
| llc.ControlFormatU | |
| self._upload_args_helper | |
| GraphUtil.generate_random_graph | |
| self.ds2.add_dimension | |
| eSTs | |
| g.es.select | |
| register_cipher | |
| redis.zadd | |
| self.builder.replace | |
| VSCtlContext | |
| np.arange(3, dtype='u8').reshape | |
| Blog | |
| u.setconfig | |
| client.copy_object | |
| Prefix | |
| self.logger.exception.assert_called_once_with | |
| datetime.timedelta | |
| trans.ngettext.assert_called_with | |
| handle_win_lib_import_error | |
| FileSystems.join | |
| temperature.pvsyst_cell | |
| cr.curve_to | |
| time_to_thaiword | |
| Part | |
| assert_pixels | |
| self._chart_canvas.yview | |
| projection.transpose | |
| titanic_data_context.build_batch_kwargs | |
| TreeEntry | |
| Perm(0, 2, 12, 19, 14)(1, 7, 18, 15, 5) | |
| values.reshape | |
| pd.Timestamp | |
| cfunc_optional | |
| J.get_static_field | |
| data_context.build_batch_kwargs | |
| _AcceptLanguage | |
| td.create_bulk_import | |
| self.tables | |
| self.proto.send_cmd | |
| t.ldngettext | |
| skip_unless_feature_version | |
| MaxRetryError | |
| self.impl.createDocument | |
| root.add_units | |
| trac26.eNilInts | |
| MessagePrelude | |
| gx.rotate | |
| np.arange(6 * 7 * 8).reshape | |
| self._to_rank_4(x).transpose | |
| xrange_ | |
| client_conn.export_keying_material | |
| widget.value_omitted_from_data | |
| pg8000.Date | |
| manager.consumer.key_partition.assert_called_once_with | |
| np.random.uniform | |
| consumer.qos | |
| pat.match('ac').group | |
| _upload.get_content_range | |
| btrfs._is_default | |
| nfa2.add_transition | |
| CreateEvent | |
| manager.assign_perm.assert_called_once_with | |
| Employee.objects.annotate(max=Window(expression=Max('salary'), partition_by=[F('department'), ExtractYear(F('hire_date'))])).order_by | |
| real_date_class | |
| self.gh.markdown.assert_called_once_with | |
| tuple_ | |
| gauss_gen_laguerre | |
| _FakeTrace | |
| CreateDataType | |
| hg.clone | |
| cr.set_source_rgba | |
| namedlist | |
| join_host_strings | |
| geod.Direct | |
| source.AbstractTrace | |
| _uniform | |
| myfunc | |
| self.conn.jconn.mockDateResult | |
| FactorRange | |
| ax.setSize | |
| _val.dimshuffle | |
| filepath.RWX | |
| v2 | |
| Popen.set_command | |
| self.wrong_value | |
| mount.set_fstab | |
| iam_backend.list_users | |
| Perm(0, 11, 8)(1, 7, 3)(4, 6, 12)(5, 17, 13) | |
| ops.RegexReplace | |
| self.generate_key | |
| jupyter_path | |
| output.dimshuffle | |
| redis.zrevrangebyscore | |
| boto_config.get | |
| EntryPoint | |
| r.getrange | |
| np.array([[cofactor_n(x, j, i) * (1 - (i + j) % 2 * 2) for j in range(x.shape[1])] for i in range(x.shape[1])]).transpose | |
| shapes.Rect | |
| context.get_batch | |
| FetchRequest | |
| fig5.add_subplot | |
| self.wait_threads.__exit__ | |
| self.allowTypes | |
| self._makeOne | |
| GVector | |
| et_needs_pyversion | |
| gen_ol(impl1) | |
| util.pycurl_version_less_than | |
| plugin.DependencyError | |
| getattr(e, method) | |
| date.strip().replace(' ', 'T', 1).replace | |
| random.randrange | |
| vid_tensor[i, :, :, :, :].permute | |
| self.s1.temperature.reshape | |
| line | |
| mock_client.assert_called_with | |
| self.backend.lookup | |
| point | |
| gl.glColor4f | |
| bulk_import.upload_part | |
| Child[int] | |
| RangeIndex | |
| geod.Inverse | |
| special.hyperu | |
| logbook.select | |
| self._ensureSet | |
| np.array([8.0, 10.0, 12.0]).reshape | |
| monkeypatch_date | |
| ks.option_context | |
| page._get | |
| Nakagami | |
| client.snapshot_path | |
| toolkit.GUIToolkit | |
| orth.eval_gegenbauer | |
| pendulum_date.pendulum.date | |
| namedtuple('cputimes', 'user nice system idle') | |
| c.addProperty | |
| self.ask_yes_no | |
| l.rename | |
| open_relative | |
| regex.match('([a-z]W)([a-z]X)+([a-z]Y)', 'aWbXcXdXeXfY').captures | |
| schema.Name | |
| EVBinarySensorConfig | |
| SceneKit.SCNMatrix4MakeRotation | |
| windows.chebwin | |
| klass.addPyMethod | |
| xy.create_line | |
| assertions.expect_deprecated | |
| CannotListenError | |
| phoenixdb.Timestamp | |
| win.ci.layout.setContentsMargins | |
| Perm(0, 1, 2, 3, 4) | |
| self._test_multi | |
| p.ci.layout.setContentsMargins | |
| Leaf.objects.only | |
| self.calendar.set_current_date | |
| surface.create_for_rectangle | |
| self.list_thing_groups | |
| get_ssl_context | |
| BoolOption | |
| self.volume_attribute.startElement | |
| (ds + Variable('dim3', np.zeros(10))).transpose | |
| self.cmd | |
| OSParser | |
| utils.signed_unpack | |
| exclusions.fails_on_everything_except | |
| self.proxy(factory).callRemote | |
| m1.js_link | |
| loaded_modules | |
| rabbitmq_cluster.joined | |
| error.pushbutton | |
| Vector3 | |
| wt | |
| virt._gen_pool_xml | |
| _test_equal | |
| libvirt_events.start | |
| UnicodeEncodeError | |
| cython.test_fail_if_path_exists | |
| find_version | |
| '{0:^15}{1:^15}{2:^15}{3:^15}{4:^15}{5:^15}'.format | |
| julian_date | |
| attention_probs.permute | |
| self.fundamental_theorem | |
| Require | |
| changes.add_change | |
| et_exclude_pyversion | |
| uri.replace | |
| filters.CommandFilter | |
| painter.drawEllipse | |
| self.feed.add_set_cell | |
| self._send_call | |
| run_privileged | |
| l.setContentsMargins | |
| str_tools.time_label | |
| convert_color_space | |
| smtp.User | |
| default | |
| a.text_retrieve | |
| EVSensorConfig | |
| self.info | |
| dest.join | |
| hp.qloguniform | |
| self.cmd_channel.log_cmd | |
| prettyForm | |
| self.filter.cell | |
| AnsiState | |
| self.signer.get_auth_instance | |
| convert.assert_called_once_with | |
| ProxyInfo | |
| get_example_dir | |
| FauxLocator | |
| stringFactory | |
| Inception | |
| BadCommand.create_path | |
| npdf | |
| Test | |
| threadpool.ThreadPool | |
| api_general_client.createTestCase | |
| ellip_harm | |
| x.dimshuffle | |
| TestPickle22 | |
| 'Test: <"&"> '.replace | |
| layout_icon_info.setContentsMargins | |
| gen_ol(impl3) | |
| idlutils.RowLookup | |
| Foundation.NSMutableDictionary.alloc().initWithObjectsAndKeys_ | |
| UnionType | |
| WUCurrentConditionsSensorConfig | |
| testdir.runpytest_inprocess | |
| nested_twice | |
| debian_ip.build_interface | |
| PhoneNumberMatch | |
| self.base_url.replace | |
| ellip_harm_2 | |
| redis.hmset | |
| x.transpose | |
| date.set | |
| desc | |
| elliprf | |
| w3.transpose | |
| self.assert_called | |
| dlib.rectangle | |
| Everything.TestObj().torture_signature_0 | |
| iscalars | |
| self.cli.create_continuous_query | |
| np.repeat(np.float64(4.0), 24).reshape | |
| retry_options.RetryOptions | |
| tukey_pvalues | |
| _with_fields | |
| c.permute | |
| unittests.common.bucket().list_live_channel | |
| fileoperations.write_config_setting | |
| _argspec | |
| pvsystem.pvwatts_ac | |
| os.path.join | |
| _DEPR_MSG.format | |
| self.progress | |
| tslearn.metrics.sakoe_chiba_mask | |
| resource.QueryParameters | |
| compat.range_g | |
| self.check_serialize | |
| r.zcount | |
| self.res.disassociate_notification_template | |
| item_fn | |
| named_tuple | |
| np.linspace(0, 10, 2 * 5 * 10).reshape | |
| maint.radiogroup | |
| self.c._on_close | |
| FrechetDistribution | |
| pdfmetrics.Font | |
| config.getboolean | |
| dc.DrawLine | |
| config._add_predicate | |
| github1.get_issue | |
| SystemConfiguration.SCDynamicStoreKeyCreate | |
| Perm(0, 11, 8)(1, 7, 3) | |
| Query(x).select_function(f).add_argument | |
| Perm(0, 16, 7)(1, 10, 11)(2, 5, 17) | |
| environ.__utils__['reg.delete_value'].assert_called_with | |
| res._set_value | |
| dog.gauge | |
| s.get_region | |
| inuse.text | |
| mapping.inverse | |
| add | |
| wrapper._delete_table | |
| c.fma | |
| exceptions.ErrorStrings.BAD_EXP_RECV.format | |
| self._minimize_model | |
| validators.Validator().allow_schemes('https', 'ssh').allow_hosts('github.com', 'bitbucket.org', 'gitlab.com', 'git.openstack.org').allow_ports('22', '443').require_presence_of | |
| redis.xgroup_setid | |
| self.lua.eval | |
| c.powmod | |
| pgdb.Date | |
| transport.TransportHost | |
| JWKParameter | |
| self.check_shorten | |
| API | |
| OperationalError | |
| get_combined_config | |
| wcs.world_to_pixel_values | |
| ec2.ARN | |
| img.clahe | |
| empty_idx._maybe_cast_slice_bound | |
| fuzz_pkt | |
| mark_point | |
| f.replace | |
| utils.check_messages | |
| np.eye | |
| client.fget_object | |
| context.set_source_rgb | |
| data.cas | |
| s.set_event | |
| store.put | |
| a.index | |
| Perm(0, 6, 17, 19, 9)(1, 11, 18, 13, 4)(2, 7, 12, 8, 3) | |
| add_newdoc | |
| self.translations.dupgettext | |
| project.create_interaction_feature | |
| self.client.basic_authentication | |
| Seq('GGGTGGTAGGG').count_overlap | |
| http | |
| ec2.assert_ | |
| assert_read | |
| self.tmp.putfile | |
| PostRotateXY | |
| op.drop_constraint | |
| stats.f.cdf | |
| errors.UnknownHandler | |
| mylock.__exit__ | |
| datetime_aliased | |
| mock_handler.emit.assert_called_with | |
| self.s2.data.lon.reshape | |
| install_mock.assert_called_once_with | |
| utils.delete_bq_table | |
| np.arange(2 * 3 * 2731).reshape | |
| q.on_declared | |
| self.validate_retry_on_session_not_availabe_with_endpoint_discovery_disabled | |
| sendfile.sendfile | |
| fatal.text | |
| self.run_test | |
| self.__aexit__ | |
| f4.append_data | |
| GIMarshallingTests.int_one_in_utf8_two_in_one_allows_none | |
| pose_map.transpose | |
| mkversion | |
| quit.setGeometry | |
| dec | |
| redis.unlink | |
| rng.uniform | |
| channel.conn.sendGlobalRequest | |
| runner.shedPrivileges | |
| self.gridLayout_2.setContentsMargins | |
| b.apply_load | |
| conn.execute | |
| trial.suggest_float | |
| Vector | |
| _CreateTransaction | |
| Dependency | |
| util.iso_to_gregorian | |
| build_static_jce_cmp | |
| filters.PathFilter | |
| Mock.mock_modules | |
| line.rfind | |
| r.linsert | |
| unpack | |
| Data | |
| cephes.obl_cv | |
| arg.find | |
| self._test_argon2_upgrade | |
| report.assert_called_once_with | |
| unittest2.TextTestResult | |
| rng.normal | |
| mysql.grant_exists | |
| SSHPrivateKey | |
| sm.distributions.zinegbin.var | |
| conn.describe_workflow_type | |
| self.h5file.create_soft_link | |
| np.full_like(data, False, dtype=bool).reshape | |
| m2.scale | |
| config.portserver_unix_socket_address.replace | |
| sv | |
| (1e-10 + (v ** 2).sum(-1)).dimshuffle | |
| self._test_open_cinder_volume | |
| conn.deprecate_workflow_type | |
| np.sin(0.78 * np.arange(27)).reshape | |
| config5.patch | |
| canvas.create_rectangle | |
| Epoch.gregorian2moslem | |
| Company.objects.values | |
| wireprotoserver.sshv2protocolhandler | |
| cornacchia | |
| helper.event_factory | |
| sm.diag | |
| pattern.set_corner_color_rgba | |
| incron.rm_job | |
| self.handler.__exit__ | |
| cephes.fdtr | |
| metrics.lerp | |
| self.fake_http_connection | |
| self.SelectNotify | |
| self.s1.lat.reshape | |
| Rotate | |
| tmp_dir.join | |
| validation_operators_data_context.build_batch_kwargs | |
| client.add_permission_for_apigateway | |
| _simple_subset_generation | |
| self.get_params_from_cli | |
| mathieusprime | |
| BetaNoncentralDistribution | |
| UnorderedGroup | |
| self.vcs._run | |
| extension.create_hook_set_value | |
| PamdRule | |
| srt_file.shift | |
| cm.__aexit__ | |
| layout_sequence.setContentsMargins | |
| self.add_shape_to_params | |
| thread_manager.error | |
| namedtuple('PeerCounterNames', ('RECV_PREFIXES', 'RECV_UPDATES', 'SENT_UPDATES', 'RECV_NOTIFICATION', 'SENT_NOTIFICATION', 'SENT_REFRESH', 'RECV_REFRESH', 'FSM_ESTB_TRANSITIONS')) | |
| np.arange(24, dtype=np.double).reshape | |
| ops.StringReplace | |
| white.read_until_cursor | |
| p.NewVariable | |
| AccordionGroup | |
| snapshot.replace | |
| Parent | |
| conn.deprecate_workflow_type.when.called_with | |
| self.p.privmsg | |
| pb.getObjectAt | |
| self.dtc.convert | |
| _compute_prob_inside_method | |
| self._textwidget.tag_remove | |
| self.vectors.relative_cosine_similarity | |
| pow | |
| fig_test.text | |
| self.conn.request | |
| self.gridLayout_3.setContentsMargins | |
| text.replace | |
| object_.torture_signature_0 | |
| '{0} {1}'.format | |
| nx.gaussian_random_partition_graph | |
| pytester.runpytest | |
| _makeUTC | |
| ExpFormat | |
| f.convert | |
| Least | |
| arrow.Arrow | |
| inst.__exit__ | |
| out.transpose | |
| np.asarray(splev(xx, tck_n2)).transpose | |
| Perm(19)(0, 6, 2)(3, 5, 11)(4, 10, 7) | |
| flags.DEFINE_boolean | |
| gl.groups.import_group | |
| np.dstack([tr.matrix().T for tr in trs]).transpose | |
| phoenixdb.Date | |
| datetime.date | |
| self.driver.Date | |
| ext.Xid | |
| img[:, :, 0:3].transpose | |
| shapes.Line | |
| hlayout.setContentsMargins | |
| phonenumbers.phonenumberutil._raw_input_contains_national_prefix | |
| UTM.from_latlon | |
| MyDate | |
| _JDBCTypePrimitive | |
| hgconfig.set | |
| qnormal_gen | |
| pat.match('b').group | |
| self.mq.send | |
| InvalidInput | |
| mocked | |
| _AcceptRanges | |
| self.grammar.set_connect_cost | |
| self.client.api_call | |
| keystone.service_create | |
| np.arange(3 * 7 * 5, dtype=np.int64).reshape | |
| map | |
| manager.__exit__ | |
| np.arange(6 * 2 * 3).reshape | |
| models.EulerAngleRotation | |
| output.permute | |
| regex.sub | |
| m.assert_called_with | |
| client._do_mount | |
| match.named | |
| UpdateXML | |
| rdh.start_point | |
| mat.add | |
| draw.color | |
| L.dimshuffle | |
| SphinxDocstring.re_type_raw.replace | |
| mock_exec.assert_called_once_with | |
| h5file.create_group | |
| self.exit_stack.__exit__ | |
| actions.register_action | |
| m._jupiter_magnitude | |
| self.register_palette_entry | |
| ('|{:^' + str(tracker_name_len) + '}|{:^9}|{:^16}|{:^11}|').format | |
| collection_ref.where | |
| dlg.SetYesNoCancelLabels | |
| Reciprocal | |
| self.conf.set_override | |
| conn.get_workflow_execution_history.when.called_with | |
| chain_to_bytes | |
| pyfunc | |
| rs.randint | |
| xmlsec.tree.find_node | |
| st.sidebar.slider | |
| q | |
| AffineVector3 | |
| ctx.set_source_rgba | |
| Model2 | |
| redis.xpending | |
| self.config.get | |
| vlayout.setContentsMargins | |
| url.path.replace | |
| context.arc_negative | |
| testing.expect_deprecated | |
| utils.safe_join | |
| Bmp | |
| cairo.MeshPattern().set_corner_color_rgb | |
| AuthorizationCodeCredential | |
| objc.NSDecimal | |
| common_function.setup_logging | |
| events.MemoryUsageThresholdExceeded | |
| Author.objects.values('name', 'article__headline', 'article__tag__name').order_by | |
| rand.uniform | |
| win.resize_and_move | |
| GDALVersion | |
| input_list.addInput | |
| browser.get_current_form().set | |
| link.SetUnderlines | |
| TypeDescription | |
| mock.call.lock.LockFile().__exit__ | |
| Interval | |
| self.initialize | |
| r.hdel | |
| libcloud_loadbalancer.create_balancer | |
| D4xx.create_error | |
| api_client.setTestCaseExecutionType | |
| dns.RRHeader | |
| self.cnx._send_cmd | |
| RangeSet | |
| source_path | |
| cephes.obl_rad2 | |
| objc.createOpaquePointerType | |
| send_cluster_time | |
| CoreFoundation.CFNumberFormatterGetDecimalInfoForCurrencyCode | |
| Keypair | |
| c.add_edge | |
| requests.NackRequest | |
| CoreFoundation.CFUUIDCreateWithBytes | |
| ptr[2].__exit__ | |
| sql.Identifier | |
| AbstractDistribution.create_path | |
| uwsgi.sharedarea_inc64 | |
| handler.add_transition | |
| demo_data | |
| Publisher.objects.annotate(num_books=Count('book')).filter(num_books__lt=F('num_awards') / 2).order_by('name').values | |
| call.foo | |
| np.arange(6, dtype=np.intp).reshape | |
| l5 | |
| client_conn.simulate_dh_gex_reply | |
| obj.pyobjc_performSelectorOnMainThread_withObject_waitUntilDone_ | |
| EC2NetworkSubnet | |
| check_available_solvers | |
| strip.replace | |
| rel_pos_embeddings.permute | |
| self.validate_metrics | |
| feed.add_item | |
| Perm(0, 4, 1) | |
| Perm(1, 4, 5)(2, 9, 10)(3, 14, 6)(7, 13, 16)(8, 15, 11) | |
| njit(function1) | |
| RequestHistory | |
| request.url.replace | |
| testdir.parseconfigure | |
| Book | |
| compat_kw | |
| betainc | |
| SlidingWindow | |
| r.pubsub_numsub | |
| master.start_stepload | |
| v.rfind | |
| canv.setFillColorRGB | |
| Quantity | |
| pm.Gamma | |
| dc.DrawRectangle | |
| Permission.objects.db_manager('other').get_by_natural_key | |
| np.where | |
| pg.SetPropertyAttribute | |
| np.expand_dims(np.expand_dims(A_Y, axis=3), axis=4).transpose | |
| should_raise(ValueError)(x.to_test) | |
| _ast27.parse | |
| self.logger.debug.assert_called_once_with | |
| np.array([[1, 2, 3], [3, 2, 1], [2, 4, 6], [6, 4, 2]], dtype=np.uint8).reshape | |
| entry | |
| row.set_cell | |
| cephes.ncfdtri | |
| np.arange(3 * 3 * 64 * 64).reshape | |
| mc.set | |
| rabbitmq.set_policy | |
| invresz | |
| addstr | |
| _translate | |
| _test_sys_exit | |
| self._ssh_worker_hosts | |
| B | |
| self.pending.put | |
| _make_version | |
| ValidationStatistics | |
| c.crypto_secretbox | |
| configparser.InterpolationDepthError | |
| td.update_schema | |
| np.arange(54.0).reshape | |
| self.domimpl.createDocumentType | |
| zeros | |
| wd.name | |
| erfa.dat | |
| ps | |
| conn.put_object | |
| bde.DocumentChangedEvent | |
| Dataclass4 | |
| existing_file_client.append_data | |
| SimplifiedBucketInfo | |
| Quartz.CATransform3DMakeScale | |
| acceptableerrors | |
| np.array(np.arange(12)).reshape | |
| self.tenant.get_site_properties_from_sharepoint_by_filters | |
| b.reshape | |
| sc.hyperu | |
| cv2.cvtColor(x, cv2.COLOR_RGB2GRAY).reshape | |
| attrconverters.cnv_boolean | |
| self.assertRange | |
| g.edges.select | |
| m._mercury_magnitude | |
| ConcatWS | |
| am.set_group_if_different | |
| res.smoothed_state_autocovariance(1).transpose | |
| wx.GridSizer | |
| printing.OperatorPrinter | |
| state._make_and_expr | |
| self.pop | |
| DicomFormat | |
| dns.Record_SOA | |
| self.x.transpose | |
| builder.MibBuilder().loadModules | |
| importlib_metadata.EntryPoint | |
| td.bulk_import_upload_part | |
| request.setApplicationServer | |
| manager.PluginVersion | |
| np.arange(3 * 3 * 3, dtype='u8').reshape | |
| PrimaryKeyConstraint | |
| mask.transpose | |
| res.predict | |
| testvars.delete_pattern_proto.format | |
| salt.utils.vmware.get_gssapi_token | |
| scanstring | |
| signed.replace | |
| DependencyError | |
| t.variables[0]._query_expansion | |
| get_config_setting | |
| SCPreferencesCreate | |
| RangeSource | |
| self.pamd.remove | |
| mock.call.forwarding.HandleForwardedIps | |
| combine_paths | |
| subplot | |
| dog.distribution | |
| debconfmod.set_template | |
| img.header.set_dim_info | |
| optuna.pruners.PercentilePruner | |
| BBox | |
| updates.edit_enum_option_key | |
| _get_csr | |
| np.arange(24, 48).reshape | |
| Condition | |
| wx.DateTime | |
| check_pan | |
| A2 | |
| X509Extension | |
| ts.tt | |
| win_ip.set_static_dns | |
| repo.ui.configlist | |
| Epoch.moslem2gregorian | |
| rng.lognormal | |
| crontab | |
| generate_test_vecs | |
| matchobj.group | |
| np_genarray | |
| cmd.cli_ctx.config.getboolean | |
| typing.TypeVar | |
| Slot | |
| c.complete | |
| TPickleV5 | |
| pytils.numeral.sum_string | |
| sorting.RangeFacet | |
| fp.RsvBits | |
| plugin.is_modified | |
| jboss7_cli.run_operation | |
| res.smoothed_state_autocovariance(3, end=end, extend_kwargs=extend_kwargs).transpose | |
| boto_vpc.create_customer_gateway | |
| http.add_certificate | |
| FeatureLocation | |
| tmpl.module.m | |
| has_at_least_one_key | |
| self.assert_dfa | |
| atom.core._qname_matches | |
| cf_p | |
| self.eigvectors.transpose | |
| Qasm | |
| col.transpose | |
| self.make_file | |
| mixed2 | |
| rep.handleReplaceBetween | |
| self.rg.logistic | |
| src.block_size | |
| ip.run_cell_magic | |
| names | |
| block | |
| message_transaction | |
| sm.distributions.zinegbin.convert_params | |
| scanner.complex | |
| op.create_unique_constraint | |
| allured_testdir.run_with_allure | |
| gen_crossed_poisson | |
| WheelCache.create_path | |
| self.t0._time.jd2.reshape | |
| objc.selector | |
| models.multi_mass_spring_damper | |
| Tile | |
| channel.Notification | |
| limits.RateLimit | |
| self.make_runner | |
| numbered_matrix | |
| add_type | |
| Quartz.CGPostKeyboardEvent | |
| pts_in_hull.transpose().reshape | |
| base_datetime.datetime | |
| self._env.pip_version.__class__ | |
| z.reshape | |
| self.ctrlLayout.setContentsMargins | |
| Error | |
| binb.install_notebook_hook | |
| mat.dimshuffle | |
| self.instance.update | |
| np.linspace | |
| r.zrange | |
| AddVersion | |
| client.__exit__ | |
| gg1 | |
| cli_runner | |
| self.gh.pull_request.assert_called_once_with | |
| protocol.HeartbeatRequest | |
| _runtest | |
| dfp._modify_instruction_label_env | |
| np.arange(2000, dtype='i4')[::2].reshape | |
| IW.transpose | |
| self.cs.flavors.create | |
| t.permute | |
| submenu.AppendCheckItem | |
| myTeamsPotentialAction1.addAction | |
| self._beam_pipeline.__exit__ | |
| self.assert_file | |
| surface.mark_dirty_rectangle | |
| struct.pack | |
| r.georadius | |
| self.contexts_dict[key].pop(-1).__exit__ | |
| PlanimeterTest.polyline.TestPoint | |
| np.linspace(-1, 3, 60).reshape | |
| self.s1.data.lat.reshape | |
| affine.Affine | |
| s.str.index | |
| gen_ol(impl6) | |
| ui_.setconfig | |
| d.Timestamp | |
| zfs.hold | |
| nd.wcs.pixel_to_world | |
| AVFoundation.AVAudioMake3DPoint | |
| BaseARN | |
| etcd_mod.watch | |
| Quartz.CGColorCreateGenericRGB | |
| pack_into | |
| self.loader.load_service_model.assert_called_with | |
| talker.add_transition | |
| fig.add_subplot | |
| cls.config.getboolean | |
| cheby1 | |
| mocked.assert_called_once_with | |
| ws.insert_bitmap | |
| row_4.set_cell | |
| BitField | |
| archive.tar | |
| cephes.hyp2f1 | |
| Hashids().encode | |
| s.insert_abs | |
| redis.georadius | |
| self._layoutbox.constrain_geometry | |
| fx_wand.rectangle | |
| Perm(0, 14, 10)(1, 9, 16) | |
| training_utils.check_array_length_consistency | |
| column_spec.replace | |
| tmp | |
| r.sunionstore | |
| open('README.rst').read().replace | |
| authClient.getGenericAnswers | |
| testvars.delete_snap_proto.format | |
| self.set_argv | |
| E.val | |
| _run_test_snippet | |
| htpasswd.useradd | |
| asyncssh.load_keypairs | |
| p.defverb | |
| FieldPath | |
| metrics.smoothstep | |
| self._execute | |
| sm.distributions.zinegbin.moment | |
| o.histc | |
| TPickleV1 | |
| r.sinterstore | |
| sch.send_scheduler_message | |
| nutation_longitude | |
| Coalesce | |
| i18n.ungettext | |
| pg.Color | |
| np.arange(9).reshape | |
| CEnumType | |
| self.head_logits_proj(attention_scores.permute(0, 2, 3, 1)).permute | |
| conn.register_workflow_type.when.called_with | |
| arranged_img_CHW.transpose | |
| ax.vlines | |
| redis.geopos | |
| self.cf.set_option | |
| Perm(19)(0, 6, 2) | |
| '{0: 8.8f}'.format(satrec.ndot * (_xpdotp * 1440.0)).replace | |
| f | |
| Geodesic.WGS84.Inverse | |
| operator.replace | |
| nt | |
| myTeamsPotentialAction3.addInput | |
| path.cubicTo | |
| self.lti_nowarn | |
| glColor4f | |
| migrations.RenameField | |
| Block | |
| DummyTokens | |
| s.update | |
| caesar | |
| self.cell_magic | |
| SaltStackVersion | |
| configparser.InterpolationSyntaxError | |
| wx.Image.RGBValue | |
| context.arc | |
| generate_day | |
| DeviceParser | |
| TermRange | |
| seq | |
| t.variables[0]._string_expansion | |
| C | |
| CoreFoundation.CFLocaleCreateCanonicalLocaleIdentifierFromScriptManagerCodes | |
| _INSTANCE_CREATE_WARNING.format | |
| collection.where('stats.product', '>', 5).where | |
| GIMarshallingTests.int_two_in_utf8_two_in_with_allow_none | |
| b.transpose | |
| filters.convert | |
| volume.startElement | |
| bf.set('u8', 8, 255).incrby('u8', 8, 1).set('u8', 8, 255).incrby | |
| tsa.exc.IntegrityError | |
| np.arange(1 * 2 * 3 * 4).reshape | |
| paramiko.util.clamp_value | |
| command_line._router | |
| Dom.getDOMImplementation().createDocument | |
| self._test_dialect_param_from_url | |
| FakeDate | |
| load_entry_point | |
| astral.Observer | |
| test | |
| re.sub | |
| c.post_request | |
| self.stuff.machine.add_transition | |
| boto.exception.StorageResponseError | |
| NamedTuple | |
| p.psubscribe | |
| client_context.require_version_min | |
| image.tags.add | |
| device_name.replace | |
| binary.bin2float | |
| wx.Region | |
| r.hincrbyfloat | |
| cs.volume_types.create | |
| solar | |
| cv.cuda.createHoughCirclesDetector | |
| self.cs.servers.set_meta_item | |
| z_crop.transpose(2, 0, 1).reshape | |
| check_success | |
| policy.permits | |
| self.h5file.create_hard_link | |
| vol.Any | |
| inverter.pvwatts | |
| T.InvalidType | |
| Request.objects.annotate(Count('items')).select_related('profile', 'location').defer | |
| _utc | |
| glayout.setContentsMargins | |
| GifFormat | |
| radio_layout.setContentsMargins | |
| cairo.LinearGradient | |
| operation.references_field | |
| redis.lset | |
| TraitPrefixList | |
| pyglet.media.synthesis.ADSREnvelope | |
| elliprj | |
| cls.objects.filter(enterprise_course_enrollment__enterprise_customer_user=enterprise_customer_user).select_related | |
| costing.text | |
| self.driver.ex_modify_server_hardware | |
| git.pull | |
| b | |
| check | |
| WL.transpose | |
| gv.reshape(B, out_H, out_W, C).transpose | |
| self.decode | |
| UserAgentParser | |
| nd2.wcs.pixel_to_world | |
| MultiMessageBox | |
| mdadm.present | |
| B.dimshuffle | |
| create_params | |
| make_password | |
| self.find_binding | |
| Signature | |
| TransitionType | |
| self.execute_command | |
| items | |
| BaseImageHeader | |
| Permutation(1, 2) | |
| DummyCtrl | |
| proxied_attribute | |
| ilo.create_user | |
| r.zrangebylex | |
| error.add_error_code | |
| numpy.array([True] * 18 + [False] * 6).reshape | |
| cephes.betaincinv | |
| rval.dimshuffle | |
| dut.api('system').set_banner | |
| NodeLocation | |
| menu.Append | |
| OnRequestMarker | |
| addProtocol | |
| numpy.arange(210, dtype='uint8').reshape | |
| typeshed.TYPESHED_PATH.joinpath | |
| TestMinAndMaxIntegers | |
| Case | |
| QDBusMessage.createSignal | |
| ' {0:40}{1:18}{2}'.format | |
| Datasubclass | |
| tenfn | |
| regex.match('(?:()|(?(1)()|z)){0,2}(?(2)a|z)', 'a').group | |
| isin | |
| page_query.add_filter | |
| log.error.assert_called_once_with | |
| circle | |
| Perm(0, 3, 9)(1, 8, 14) | |
| np.arange(5 * 6 * 7 * 8).reshape | |
| javabridge.make_instance | |
| jutil.make_method | |
| DemoSwitch | |
| message.remove_headers | |
| fi | |
| self.printer.writelines | |
| self.related.convert | |
| attention_scores.permute | |
| results.pivot | |
| qs1.union(qs1).values | |
| awsclient.create_function | |
| LiveChannelAudioStat | |
| check_bin_op | |
| chainerx.tri | |
| self.get_dns_mock_object | |
| self.mime_test_file | |
| hp.iso | |
| self.make_simple_runner | |
| child.tags.add | |
| StorageLevel | |
| Protected | |
| TPickle2 | |
| np.repeat(np.float32(3.0), 24).reshape | |
| Perm(0, 11, 15)(1, 17, 14)(2, 18, 9)(3, 12, 13)(4, 7, 19) | |
| config.get_boolean | |
| a.replace | |
| runner._task_stderr_path | |
| x.replace | |
| trans.__exit__ | |
| association.Association | |
| RECT | |
| util.pending_deprecation | |
| verify_socket | |
| self._hyper2.SetColours | |
| Property | |
| self.rs.rstr | |
| Tag | |
| ply_list_a | |
| lc.SetItem | |
| cm.__exit__ | |
| p_tryon.squeeze(0).transpose | |
| templatespec | |
| m._earth_magnitude | |
| MethodTest.TestValueParamsArg | |
| AppellF1 | |
| testdir.makefile | |
| BITBUCKET.get_pipeline_step | |
| m6.translate | |
| self.rg.noncentral_f | |
| AppKit.NSColor.colorWithCalibratedHue_saturation_brightness_alpha_ | |
| td.put.assert_called_with | |
| Jplus.matrix_element | |
| boto.config.getfloat | |
| np.array([12, 16, 24, 28]).astype(np.int32).reshape | |
| S_BLK_HDR.pack | |
| np.array([11, 10, 7, 6], dtype=np.float32).reshape | |
| IgnoreList().exclude | |
| parser.parse | |
| Perm(0, 7, 9)(1, 11, 4) | |
| Jminus.matrix_element | |
| _Node | |
| ddt.data | |
| Wigner6j | |
| GLfloat * 5 | |
| ibis.coalesce | |
| out.note_off | |
| r.lpush | |
| cs.volume_types.update | |
| Layout | |
| c.drawImage | |
| inst.get | |
| self._light.set_color | |
| lowlevel.SignalMessage | |
| histogram1.record | |
| StreamingKMeans(k=2, decayFactor=1.0).setRandomCenters | |
| flask.request.url.replace | |
| mock.assert_awaited_with | |
| self.time.shift | |
| EnumField | |
| install_req_from_line.create_path | |
| local_datetime | |
| HRef | |
| self.ops.datetime_extract_sql | |
| _lookup_by_attr_factory | |
| data['foo'].replace | |
| gdata.gauth.generate_auth_header | |
| mock_cluster_resp_ok.cluster | |
| self.config.setbool | |
| fields.BitField | |
| img.blur | |
| XmlPart | |
| self.write_one_level | |
| Company.objects.values('name', 'num_employees', 'num_chairs').order_by | |
| RayTransferMatrix | |
| Completion | |
| handler.__exit__ | |
| self._write_sub_border | |
| a.add_edge | |
| fortran | |
| wx.SplitterRenderParams | |
| np.arange(2 * 5 * 3).reshape | |
| r.ui.setconfig | |
| win_file.stats | |
| wx.DateTime.FromDMY | |
| self.cli.create_retention_policy | |
| paths.join | |
| dt_module.date | |
| self.env.register | |
| mibViewController.mibBuilder.importSymbols | |
| fprogress | |
| Init | |
| lerchphi | |
| tools.ObjArrayHelperTemplate | |
| values.str.rfind | |
| der.encode_oid | |
| info.get | |
| models.ContentDate.objects.filter(course_id=course_id, active=True, **rel_lookup).select_related('policy').only | |
| draw.viewbox | |
| func_numexpr | |
| web.configbool | |
| Gdk.Color | |
| db.eval | |
| conn.set_lb_listener_SSL_certificate | |
| sh.dotenv | |
| pastel.add_style | |
| my_obj.delete_snapmirror | |
| GLfloat * 8 | |
| MethodTest.TestOneArgWithParams | |
| self.client.archive | |
| rsa_private_key | |
| np.random.randint | |
| is_archive_file.create_path | |
| mock_logger.debug.assert_called_with | |
| cupy.random.randn | |
| search.NumericFacet('numfield').add_range | |
| self.service_connection.set_desired_capacity | |
| rgb_to_hsl | |
| im_patch.transpose | |
| ngettext_lazy | |
| gs.translate | |
| y_scale.reshape | |
| dscalars | |
| options.BoolOption | |
| self._parse_initializer_list | |
| self.runModuleAsMain | |
| register_plugin | |
| np.array(coreml_out)[:, :, ::-1].transpose | |
| itemgetter | |
| Perm(0, 5, 10, 6, 1) | |
| DummyAccount | |
| Select.render_option | |
| handler.call | |
| self.store.put | |
| TooMany | |
| mobj.group | |
| self.vm.import_module | |
| udp.udp | |
| self._getTimezoneOffsetTest | |
| Client.assert_called_with | |
| vi_pos_to_char_forward | |
| is_group_member | |
| bcr.RGB | |
| html_url.replace('https://github.com/', 'https://raw.githubusercontent.com/').replace | |
| mpl.cbook._rename_parameter | |
| EnumList | |
| self.parser.expected_name | |
| self.module.LoadLibraryEx | |
| Perm(0, 8, 15)(1, 12, 16)(2, 18, 10)(3, 19, 5) | |
| test_resolve | |
| graph.add_edge | |
| bob | |
| DummyProducer | |
| p.push | |
| self.type2test.maketrans | |
| url_query_parameter | |
| logger.opt(colors=True).log | |
| rendering.vector_to_gl | |
| res.smoothed_state_autocovariance(2, end=end, extend_kwargs=extend_kwargs).transpose | |
| bx.pop | |
| testdir.makepyfile | |
| nsdecls | |
| self.check_windows_exception | |
| self.api.createTestCase | |
| mock_open.assert_called_once_with | |
| self._hyper2.GotoURL | |
| stats.hypergeom.rvs | |
| l | |
| self.devsetbox.tag_remove | |
| eye | |
| _FT_IMAGE_TAG | |
| Path | |
| builder.add_language_system | |
| serialize | |
| costing.pushbutton | |
| np.asarray(Image.open(path)).transpose | |
| a.g | |
| np.arange(2 * 3 * 5 * 7).reshape | |
| rfc1902.ObjectIdentity | |
| _HeadTable | |
| ReadFromPubSub | |
| gtp.TBCDByteField | |
| pgdb.Timestamp | |
| DemoYoutubePlayer | |
| mean.dimshuffle | |
| _get_cmd | |
| np.arange(480000.0).reshape | |
| histogram2.record | |
| newseq_btnbar.setContentsMargins | |
| NamespacedAttribute | |
| assoc | |
| NavigationNodeCreationInformation | |
| cron.set_job | |
| CoreFoundation.CFStringCreateMutableCopy | |
| gc.set_threshold | |
| Window | |
| osp.join | |
| cephes.obl_rad2_cv | |
| Text | |
| SimpleRow | |
| hp.uniformint | |
| func.substring | |
| Loc | |
| h.dimshuffle | |
| HangoutsCredentials | |
| snmpEngine.msgAndPduDsp.mibInstrumController.mibBuilder.importSymbols | |
| self.rand | |
| Vectors.dense | |
| self.res._disassoc | |
| max | |
| test_name.replace | |
| _dynamic_max_trials | |
| graph.remove_transform | |
| gen_ol(impl9) | |
| label.replace | |
| td.partial_delete | |
| mutabletuple | |
| rfc3986.validators.Validator().require_presence_of('scheme', 'host').check_validity_of | |
| command | |
| XMLSyntaxError | |
| mock_assoc.assert_called_once_with | |
| state.sls | |
| self._batcher.report_latency | |
| d22v | |
| color | |
| Warning | |
| Updater | |
| wx.DateTime.FromHMS | |
| FixedOffsetTimeZone.fromSignHoursMinutes | |
| self.check_conv_outsize | |
| netscaler.servicegroup_server_delete | |
| metric_name.replace | |
| self.br.update_device_mtu | |
| self.get_models | |
| Quartz.CGGetActiveDisplayList | |
| glTranslatef | |
| context.curve_to | |
| s.replace | |
| virt.network_running | |
| sm.distributions.genpoisson_p.pmf | |
| jenkins.Jenkins | |
| self.file.__exit__ | |
| Module | |
| QMessageBox.information | |
| t.suggest_uniform | |
| self.github_repository.replace | |
| K.transpose | |
| sym_spell.load_dictionary | |
| HLine | |
| d.pop | |
| JSONExtract | |
| chainer.links.Convolution2D | |
| SinusoidalConversion | |
| BoundingBox | |
| self._test_cloud_tmp_cleanup | |
| self.layout.setContentsMargins | |
| numeral.get_plural | |
| client.GoalQuery | |
| btrfs.delete | |
| _iteritems_args_kw | |
| build_one_inside_env.create_path | |
| self.uencode | |
| pct_to_int | |
| np.can_cast | |
| index_getter | |
| Method | |
| cls.exceptionWithName_reason_userInfo_ | |
| BuiltinMethod | |
| obj.pyobjc_performSelectorOnMainThread_withObject_modes_ | |
| Perm(19)(0, 6, 2)(3, 5, 11)(4, 10, 7)(8, 14, 17) | |
| openstack_config.get | |
| NodeImage | |
| pstr | |
| self.MockMessage | |
| w.set_geometry_hints | |
| configparser.DuplicateSectionError | |
| line_content.replace | |
| menu5.Append | |
| RedditAPIException | |
| self.check_swap_fds | |
| r1.reshape | |
| self.checkIntType | |
| info.add_itxt | |
| sc.bdtrc | |
| self.fetest | |
| self.axle.set_color | |
| geomspace | |
| SlidingWindows | |
| op | |
| execmodel.fdopen | |
| LunarMixin.lunar | |
| Setting | |
| StateSpace | |
| remove_quotes_parser | |
| sm.distributions.genpoisson_p.logpmf | |
| mock_open.assert_called_with | |
| np.arange(300, dtype=np.float32).reshape | |
| call | |
| context.load_verify_locations.assert_called_with | |
| self.position | |
| Perm(0, 16, 13)(1, 17, 8)(2, 11, 12)(3, 6, 18)(4, 10, 19) | |
| abort | |
| uwsgi.sharedarea_write32 | |
| ibm_db.connect | |
| Epoch | |
| validators.Validator().allow_schemes('https', 'ssh').allow_hosts('github.com', 'bitbucket.org', 'gitlab.com', 'git.openstack.org').allow_ports('22', '443').require_presence_of('scheme', 'host', 'path').check_validity_of | |
| highlight | |
| sym_spell.load_bigram_dictionary | |
| metrics.Point | |
| rng.randint | |
| testvars.ilm_delete_proto.format | |
| html_tag_eq | |
| conn.putheader | |
| webapp2.Route | |
| sync_dynamic | |
| Perm(0, 2, 3) | |
| example | |
| pg.Rect | |
| cephes.pro_ang1_cv | |
| self._update_body | |
| HSL | |
| config.option._regexp_validator | |
| conf.str_pyobject | |
| __utils__['reg.read_value'] | |
| layer.blobs[0].transpose | |
| self.set_state | |
| linspace | |
| np.arange(4).reshape | |
| DockerContainer('localstack/localstack:{}'.format(LOCALSTACK_VERSION)).with_env('SERVICES', 'kinesis').with_env('KINESIS_PORT', '4568').with_env('USE_SSL', 'true').with_exposed_ports(4568).with_volume_mapping | |
| self.factory.get | |
| model._Breakend | |
| make_order | |
| self.config.set | |
| deprecate_param | |
| ts.tai | |
| FieldLenField | |
| RawDataElement | |
| transport.request | |
| x_st.transpose | |
| xattr.write | |
| hyper2.SetUnderlines | |
| res.smoothed_state_autocovariance(-3, extend_kwargs=extend_kwargs2).transpose | |
| batch.expect_column_values_to_be_between | |
| mock_ssh_file | |
| D | |
| NormalGammaDistribution | |
| skip_before_postgres | |
| np.arange(4 * 3 * 2).reshape | |
| pytils.numeral.get_plural | |
| v.slice | |
| api.add_entry | |
| boto_route53.delete_record | |
| meta.setPixelsDimensionOrder | |
| configuration.get_config().get | |
| a[:-1].transpose | |
| _make_attribute_value_state | |
| hotp.get_provisioning_uri | |
| _PROPS | |
| mgr.create_station | |
| cartesian_to_spherical | |
| self.api.getReqSpecCustomFieldDesignValue | |
| Foundation.NSArray.alloc().initWithObjects_ | |
| self.t0.jd1.reshape | |
| urllib.quote(x.encode('utf-8')).replace('%2C', ',', 'g').replace | |
| canvas.create_oval | |
| NegativeMultinomial | |
| permission_checker.require_any | |
| get_test_data | |
| boto.config.setbool | |
| __connarg | |
| psturng | |
| VcsSupport.create_path | |
| self.given_dtype | |
| testdir.inline_run | |
| ret_key.replace | |
| tf.flags.DEFINE_multi_string | |
| run | |
| self._config_user.__exit__ | |
| gt_for_colbars.reshape | |
| self._testProcess | |
| fig2.add_subplot | |
| click.option | |
| Dagum | |
| vi_pos_word_short | |
| stats.nbinom.pmf | |
| extra_space.replace | |
| self.assert_unpack | |
| np.random.RandomState(0).randint | |
| dns.rrset.from_text | |
| pstats.Stats | |
| ws.getInfoForFile_application_type_ | |
| app.ui.config | |
| self.splitter.setContentsMargins | |
| develop._resolve_setup_path | |
| StateManager | |
| obs3_gray.reshape | |
| query.add_filter | |
| np.expand_dims(np.expand_dims(A_X, axis=3), axis=4).transpose | |
| pattern.set_control_point | |
| zk_concurrency.min_party | |
| main_sheet.set_column | |
| composer.update | |
| self.proto._set | |
| urllib.quote(x.encode('utf-8')).replace('%2C', ',', 'g').replace('%3A', ':', 'g').replace | |
| func.replace | |
| QuotedString | |
| Cycle | |
| create.text | |
| Perm(0, 16, 13)(1, 17, 8)(2, 11, 12) | |
| mytype2.set_fields | |
| AppKit.NSGetInformationalAlertPanel | |
| tensor.matrix().dimshuffle | |
| skipUnlessDBFeature | |
| datetime_.time | |
| WheelDistribution.create_path | |
| TemporaryUploadedFile | |
| slicer | |
| async_exec | |
| Size | |
| range | |
| auth_required | |
| mimetypes.add_type | |
| webhook_item._set_values | |
| Foundation.NSGetSizeAndAlignment | |
| np.asarray(ptr).reshape(img.height(), img.width(), 4).transpose | |
| log_row | |
| self.Integers | |
| types.Enum | |
| testdir.tmpdir.dirpath | |
| self.filesystem.joinpaths | |
| self.func | |
| utils.env | |
| am.set_mode_if_different | |
| p.group | |
| test_function | |
| gdata.auth.GenerateClientLoginRequestBody | |
| path_get | |
| report.longrepr.addsection | |
| Foundation.NSMakeRect | |
| self._local_rename | |
| prep.text | |
| error.RedirectWithNoLocation | |
| self.metric_name | |
| mean_obliquity | |
| special.nbdtr | |
| self._qos_add | |
| dnn_conv | |
| D3xx.create_error | |
| self.entry.AddCategory | |
| head_ref.replace | |
| browser.new_control | |
| builder_ifbranch.add_activation | |
| set_conf | |
| fig.text | |
| query.NumericRange | |
| g.st_mincut | |
| loop_body_builder.add_copy | |
| refraction_angle | |
| self.ie._parse_html5_media_entries | |
| zeta | |
| client.obtain_token_by_authorization_code | |
| decorated | |
| self.app.control.election | |
| ui.configint | |
| catalog.queryPluralMessage | |
| host.replace | |
| LiveChannelVideoStat | |
| w.wcs_pix2world | |
| c.head_object | |
| recordtype | |
| Cocoa.NSColor.colorWithDeviceRed_green_blue_alpha_ | |
| make_distribution_for_install_requirement.create_path | |
| pytree.LeafPattern | |
| Bhattacharyya_coefficient | |
| StereographicConversion | |
| self.rg.gumbel | |
| flags.DEFINE_multi_string | |
| store.tags(*tags).put | |
| self._set_git_diff_output | |
| oracledb.Date | |
| MockONTAPConnection | |
| v.find | |
| self.page.Jeval | |
| self.__test_instance.weather_at_places_in_bbox | |
| p.establish_colors | |
| qs1.difference(qs2).values | |
| self.pdc.DrawEllipse | |
| api_general_client.getTestCaseCustomFieldDesignValue | |
| Callable(CallableClass()) | |
| Generation | |
| compewireprotosupport | |
| self._get_expected_args_list | |
| sum_of_squares | |
| h3.geo_to_h3 | |
| ReasonCodes | |
| Field | |
| DataRow | |
| digest.adduser | |
| PygameVersion | |
| _get_components | |
| rstate.randn | |
| redisA.migrate | |
| self.hboxlayout1.setContentsMargins | |
| ProcessCommunicationStdoutEvent | |
| tf.app.flags.DEFINE_float | |
| pixbuf.add_alpha | |
| Callable(lambda x, y: x + y) | |
| nthroot_mod | |
| call.write | |
| rtd.project_version_update | |
| ScriptThatMakesFileTest | |
| stringified_dict_contains_value | |
| hdf.select | |
| self._simple_interactive_menu | |
| DocumentDigest | |
| self._assert_never_installs_python3 | |
| ReturnValueOnlyEnumMember | |
| tmpdir.mkdir | |
| frame1.reformat | |
| check_messages | |
| DataElement | |
| sh | |
| r.add_edns | |
| obj.pyobjc_performSelector_withObject_afterDelay_inModes_ | |
| mock_download_tarball_by_url.assert_called_with | |
| cfunc | |
| colgen | |
| DemoAirQuality | |
| stats.trapz.pdf | |
| fetcher.fetch.assert_called_once_with | |
| builder.add_activation | |
| numpy.arange(96).reshape | |
| self.conn.frame_writer.assert_called_with | |
| redis.connection.Encoder | |
| Config.getdefault | |
| FakeVersionInfo | |
| attr | |
| m6.scale | |
| inst.Overloaded[str] | |
| listener | |
| mibBuilder.loadModules | |
| flam | |
| page.replace | |
| np.arange(60, dtype=np.float64).reshape | |
| l.aggregate | |
| util.switchUID | |
| TBCDByteField | |
| loader.load_service_model.assert_called_with | |
| pg.mkBrush | |
| testui.setconfig | |
| _process_module_definition | |
| euler2mat | |
| client_context.version.at_least | |
| get_installed_distributions.create_path | |
| select([adapter.columns[expr] for expr in exprs]).apply_labels().order_by | |
| ec1.assert_ | |
| foo.should_receive('__iter__').and_yield | |
| self.service_connection.get_all_rrsets | |
| Gumbel | |
| cephes.mathieu_modcem1 | |
| build_one.create_path | |
| reduce | |
| sagemaker.utils._module_import_error | |
| c.Connection | |
| TestObject.objects.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'}).values_list | |
| funcs._scipy_kraft_burrows_nousek | |
| Perm(0, 1, 2) | |
| r.zrangebyscore | |
| TaggingService | |
| self.state.add_transition | |
| self.child.recv | |
| m.StrIssue | |
| SVGSurface | |
| f.subplots_adjust | |
| Employee.objects.annotate(avg_salary=Window(expression=Avg('salary'), order_by=F('department').asc(), partition_by='department')).order_by | |
| diff.replace | |
| f3.append_data | |
| shortnumberinfo._match_national_number | |
| _util.author_info | |
| sch.task_list | |
| DummyRequest | |
| generateTemplates | |
| qloguniform_gen | |
| ScenarioOutline | |
| source._view | |
| pandas_datareader.DataReader | |
| app.add_route | |
| Event | |
| VerticalExpander().register | |
| SFTPVFSAttrs | |
| self.p.sendMessage | |
| path_info.replace | |
| mock_client.create_terms_of_service | |
| timeout.ExponentialTimeout | |
| self.translations.lngettext | |
| ClassMultiInheritance | |
| self._blankOne | |
| SceneKit.SCNMatrix4MakeScale | |
| self.networkops.couple_nic_to_vswitch | |
| np.arange(10.0, 18.0).reshape | |
| mathieucprime | |
| qs | |
| tsriov._check_sys_vnic_capabilities | |
| sqrt_mod | |
| p4.translate | |
| indexedarray2.sort | |
| obj.addAll | |
| np.linspace(5, 10, 10 * 3).reshape | |
| np.arange(2 * 1 * 3 * 1 * 4).reshape | |
| GammaProcess | |
| Fault | |
| self._loader.path_dwim_relative_stack | |
| str_tools._to_camel_case | |
| LessEqual | |
| zypper_mock.assert_called_once_with | |
| rtc.BeginSymbolBullet | |
| '{0:<20s} {1:>16s} {2:>16s}\n'.format | |
| store.tags('bop').put | |
| get_ref_im | |
| wrapper_element.query_all | |
| assert_not_equal | |
| And | |
| RequirementPreparer.create_path | |
| query_params | |
| Perm(0, 16, 13)(1, 17, 8) | |
| c.getiterator | |
| urwid.ProgressBar | |
| CommandInfo | |
| np.arange(30).reshape | |
| self.rtc.BeginNumberedBullet | |
| self.gh.create_issue | |
| stats.hypergeom.ppf | |
| self.relay.sentMail | |
| metrics.metric_name | |
| base.ensure | |
| dfs_account_url.replace | |
| hp.Via | |
| constraint.SingleValueConstraint | |
| git_cmd | |
| _display_header | |
| self.cli_ctx.config.getboolean | |
| cls.mockserver.__exit__ | |
| IPv6Address | |
| uninstall_mock.assert_called_once_with | |
| self.TestLanguageRulesCheck | |
| fig3.add_subplot | |
| explain_completion | |
| _PubSubSource | |
| FeatureLibLocation | |
| poster.encode.encode_string | |
| self.dmp.diff_main | |
| regex.subfn | |
| count.setGeometry | |
| config | |
| g.mincut_value | |
| groupadd.add | |
| Symbol | |
| ellipfun | |
| mock_ext_pillar_func.assert_called_once_with | |
| validators.Validator().allow_schemes('https', 'ssh').allow_hosts | |
| self.o.dimshuffle | |
| self.cl.set_monthly_billing | |
| self.context.set_source_rgb | |
| self.make_worker_file | |
| m.span | |
| declarations.PostGenerationMethodCall | |
| Y | |
| cephes.betainc | |
| pear.tags.add | |
| create_page | |
| self.match_wild_star | |
| color.getCyan_magenta_yellow_black_alpha_ | |
| cephes.mathieu_modsem2 | |
| self.client.CreatePage | |
| CompositeKey | |
| generator | |
| inputData.transpose | |
| http_get.ConvertSpeed | |
| query2.where | |
| Foundation.NSArray.arrayWithObjects_ | |
| gflags.TextWrap | |
| AppKit.NSColor.colorWithDeviceCyan_magenta_yellow_black_alpha_ | |
| haproxyconn.wait_state | |
| self._smutclient.uncouple_nic_from_vswitch | |
| elasticsearch.mapping_create | |
| run_command | |
| handler.publish | |
| conn.register_activity_type | |
| fonction | |
| ircsupport.IRCAccount | |
| self.conn.getChannel | |
| readtle | |
| wcs_topo.pixel_to_world | |
| screen.tty_signal_keys | |
| m.I.add | |
| stack(m).permute | |
| result[1].reshape | |
| pubdata.replace | |
| check_manifest.IgnoreList().global_exclude | |
| self.networkops.uncouple_nic_from_vswitch | |
| a.dimshuffle | |
| d21 | |
| access_logger.log | |
| _ContentRange | |
| fixture.__exit__ | |
| self.run_temp_dir_check | |
| shutil.ignore_patterns | |
| td.add_user | |
| np.array([x, y]).T.reshape | |
| versions.Version | |
| drac.nameservers | |
| Enum | |
| filters.dimshuffle | |
| hp.qlognormal | |
| tracker | |
| self._connection.execute_nonquery | |
| cli.UI | |
| monitoring_infos.create_monitoring_info | |
| p.drawLine | |
| np.asarray(img, np.float32).transpose | |
| cost.text | |
| cf._compute_standard_errors | |
| arange(36).reshape | |
| ApiVersionsSpec | |
| rw_handles.VmdkHandle | |
| _ErrorFormatter | |
| self.devsetbox.tag_add | |
| smc._contrast_pairs | |
| Cocoa.NSRunAlertPanel | |
| putils.execute | |
| DNSTestRecord | |
| mock.assert_any_await | |
| cephes.mathieu_modsem1 | |
| incremental.Version | |
| SceneKit.SCNMatrix4MakeTranslation | |
| Permutation.josephus | |
| attr_mo.group | |
| s3._get_key | |
| img.transparent_color | |
| f.create_group | |
| store.tags(*tags2).put | |
| r.script_exists | |
| earthlib.refraction | |
| client_class.assert_called_once_with | |
| next.is_delim | |
| lambertw | |
| Perm(0, 11, 15) | |
| Member | |
| writer.add_scalar | |
| self._gen_data | |
| JPypeReference | |
| coalesce | |
| ReadOnlyCredentials | |
| gcol.transpose | |
| self.runIn | |
| np.arange(27, dtype='i4').reshape | |
| test_mpnet._build_segment | |
| KeyPress | |
| gegenbauer | |
| t.setStrokeColorRGB | |
| code.replace | |
| line_content.replace("'(", '(', 1).replace | |
| np.random.random(70).reshape | |
| Perm(0, 4, 7, 3) | |
| shell.complete_open | |
| os_testr.construct_regex | |
| wrap_nest | |
| Path(arrays, kdims=['x', 'y'], datatype=[self.datatype]).add_dimension | |
| self.check_isolated_token | |
| rslt.params_sensitivity | |
| nn.MaxPool2D | |
| self.check_conv_outsize_cover_all | |
| months2days | |
| self.check_that_attribute_has_been_set | |
| histogram.record | |
| PX.BranchColor | |
| a.rfind | |
| locale.pgettext | |
| pygame.cursors.Cursor | |
| self._testRedirectURI | |
| UnicodeDecodeError | |
| User.objects.create_user | |
| m.pos_kw_only_mix | |
| '{:20} : {:5} {} {}'.format | |
| self.check_error | |
| self.mime_test_mimedb | |
| submission_qs.select_related('student_item').filter(student_item__course_id=course_id, student_item__item_id=item_id, student_item__item_type=item_type).order_by | |
| com.GUID | |
| self._download_webpage_handle | |
| _message_with_time | |
| pm.Beta | |
| array2.argsort | |
| new_bounds_to_old | |
| mount.set_automaster | |
| data_context_parameterized_expectation_suite.build_batch_kwargs | |
| pm.c | |
| extension.create_hook_prepend_value | |
| gen_permissions | |
| self.mibBuilder.importSymbols | |
| array3.sort | |
| mkdate | |
| merge | |
| array([], dtype=float64).reshape | |
| Permutation | |
| np.matmul(a, b).transpose | |
| self._test_strtype | |
| a.transform | |
| self._write_cell_style | |
| td.change_database | |
| OSError | |
| tcp.tcp | |
| group | |
| self.g.es.select | |
| self.datetimecls | |
| mkTest | |
| self.driver._build_scheduling_gce_struct | |
| m.TestFactory1 | |
| Callable(mixed_example) | |
| boto.config.get | |
| Substr | |
| self.p.action | |
| _matmul(_matmul(R.transpose(0, 2, 1), V_invsqrt, xp), eigvectors.transpose(0, 2, 1), xp).transpose | |
| buf.getvalue().replace | |
| SystemConfiguration.SCPreferencesCreate | |
| etcdctl | |
| table.getName | |
| optdb.add_tags | |
| deltat.reshape | |
| cephes.btdtri | |
| add_dict_entry | |
| mock.assert_awaited_once_with | |
| js.substring._matches | |
| values.str.slice_replace | |
| entry.__exit__ | |
| frame.window_frame_start_end | |
| inst.localtrace | |
| system.sapm_celltemp | |
| boto.config.get_value | |
| Foundation.NSMutableArray.alloc().initWithObjects_ | |
| _funky_classmethod | |
| config6.patch | |
| XmeansTestTemplates.templateMaxAllocatedClusters | |
| SubDatetime | |
| Metrics.counter_hit_miss | |
| unparse_color | |
| _ClientCallDetails | |
| self.settings.set | |
| regex.split | |
| makeName | |
| _warn_deprecated | |
| self.basic_error | |
| manager.assign | |
| InstallCommand.create_path | |
| previous_rule.prev.matches | |
| _FT_ENC_TAG | |
| ds.add_new | |
| Wheel.create_path | |
| self.networkops.delete_nic | |
| PasswordHasher | |
| self.s2.obsgeoloc.reshape | |
| d.Date | |
| com.all_not_none | |
| self.gi.workflows.export_workflow_to_local_path | |
| spack | |
| pg8000.Timestamp | |
| net.VNet.bld | |
| _literal | |
| encoded.reshape | |
| '{:10} {:10} {:10}'.format | |
| _mighty_wurlitzer.__exit__ | |
| github3.pull_request | |
| c.set_cookie | |
| self.progressDlg.__exit__ | |
| r.zincrby | |
| self.instance.create_issue | |
| v.rindex | |
| cuda.elementwise | |
| block.add_new | |
| handle | |
| routing_range.Range | |
| np.arange(128).reshape | |
| process.__exit__ | |
| '{0:s}\t\t{1:s}\t\t{2:s}\t\t{3:s}'.format | |
| repo.get_store().should_receive('put').never().with_args | |
| nx.uniform_random_intersection_graph | |
| client.read | |
| plt.figure().add_subplot | |
| wx.RichMessageDialog | |
| CppMethodDef | |
| github.get_project | |
| cephes.obl_ang1_cv | |
| self.driver.Timestamp | |
| r.eval | |
| fig6.add_subplot | |
| cephes.pro_rad1 | |
| host_config_version_error | |
| self.dmp.match_main | |
| cftime.datetime | |
| ok_trial | |
| c.add_transition | |
| input_generator.positive_increasing | |
| _up | |
| Rule | |
| g.triplets.sort('src.id').select | |
| flags.DEFINE_integer | |
| name.replace | |
| proxy_property_directly | |
| v1.AddBinding | |
| IntOption | |
| self.channel.basic_consume | |
| attribute.replace | |
| super(_UTC, self).__init__ | |
| GreaterEqual | |
| shell.complete_attr | |
| link.SetColours | |
| special.radian | |
| bindings.add | |
| function1 | |
| self._create_body | |
| dataset.expect_column_values_to_be_between | |
| InstallationError.create_path | |
| x.permute | |
| cfg.set | |
| n.update | |
| conv_utils.conv_output_length | |
| ply_abc | |
| Platform | |
| common_function.execute | |
| dns.Record_SSHFP | |
| run_with_locale | |
| Qubit | |
| Proxy.objects.defer | |
| tls_certificate_authority.issue_server_cert | |
| job._JobReference | |
| updating.updated_kwarg_default_value | |
| requests.DropRequest | |
| cairo.MeshPattern().curve_to | |
| plat_specific_errors | |
| TVector3 | |
| faces.reshape((400, 64, 64)).transpose | |
| datastore_trace | |
| w.strip(punctuation).replace | |
| mail.alias.AddressAlias | |
| g.activity | |
| draw.alpha | |
| np.arange(24).reshape | |
| Normal | |
| self.cursor.execute | |
| OffsetCommitRequest | |
| pyglet.gl.glClearColor | |
| Hashids().encrypt | |
| MethodTest.TestNonParamsArrayInLastPlace | |
| self.cli.revoke_privilege | |
| css_bytes.find | |
| mock_stream.__exit__ | |
| generic_expander | |
| req.ui.setconfig | |
| lfsr_autocorrelation | |
| self.A.rfind | |
| data.pivot | |
| np.zeros(9 ** 3, dtype=np.int32).reshape | |
| self.assert_pth_and_source_work_together | |
| Person.objects.only | |
| c.setStrokeColorRGB | |
| res.smoothed_state_autocovariance(1, end=end, extend_kwargs=extend_kwargs).transpose | |
| self.f.require_dataset | |
| ArmyGlyph | |
| UniformIntegerHyperparameter | |
| TypeVar | |
| self._cache_override.__exit__ | |
| numpy.arange | |
| peek.is_delim | |
| self.assertConverted | |
| self.pdc.DrawRectangle | |
| cls | |
| np.linspace(0, 25, 60).reshape | |
| firewalld.remove_port_fwd | |
| tu.colorize_ansi | |
| ParsedPath | |
| appfs.UserDataFS | |
| self.op.schema_obj.check_constraint | |
| QuadraticU | |
| method | |
| pygame.Color | |
| self.VarArgs | |
| td.api.history.assert_called_with | |
| otConverters.Long | |
| execute_iptables_cmd | |
| virtualenv_mod.managed | |
| cephes.hyp1f1 | |
| postgres._maybe_encrypt_password | |
| self.h5file.create_group | |
| self.cache.set | |
| special.nbdtri | |
| td.run_schedule | |
| mock.__exit__.assert_called_with | |
| temperature.faiman | |
| r.zremrangebyscore | |
| statsd.connection.Connection.set_defaults | |
| settings.get | |
| vi_pos_to_char_backward | |
| store.tags('zap').put | |
| a.text_store | |
| out_tf.transpose | |
| a.reshape | |
| startElement.assert_called_with | |
| ProcessLogStdoutEvent | |
| instance.create_station | |
| build | |
| iname.replace | |
| read_mock.assert_called_once_with | |
| compounding | |
| TestPickle2 | |
| target.transpose | |
| context.assert_ | |
| self.add_message | |
| modify_point | |
| trial.suggest_discrete_uniform | |
| Namespace | |
| C.resize | |
| Bucket | |
| self.instance.create_with_secret | |
| self._table_stub_internal.__exit__ | |
| Popen.set_default | |
| E | |
| venv.run | |
| mock.call.default | |
| Rotation | |
| ops.lookup_constraint | |
| rval((2, 2, 2, 2, 2)).transpose | |
| self.instance.create_review_comment | |
| canvas.drawString | |
| ZerosPolesGain | |
| global_tempdir_manager.create_path | |
| com.any_none | |
| sm.distributions.zinegbin.mean | |
| MovedAttribute | |
| arg_ctx.ignore | |
| myTeamsPotentialAction3.addAction | |
| redis.zinterstore | |
| self.g.maxflow | |
| fig.patch.set_bounds | |
| scipy.sparse.rand | |
| get_config_vars | |
| mtransforms.Bbox.from_extents | |
| encode_value_in_name | |
| deprecated_property | |
| psycopg2.Time | |
| m1.add_transition | |
| nt('event', 'xdata ydata inaxes button') | |
| soup.b.insert_before | |
| get_link_mock.assert_called_once_with | |
| QGraphicsScene | |
| x[4:6, 1:11:6, 1:5].transpose | |
| gradient.add_color_stop_rgb | |
| conv.dimshuffle | |
| c.format | |
| SlidePart | |
| self.assertNotRegex | |
| inspect.ArgSpec | |
| AVFoundation.AVAudioMake3DVector | |
| first_handler.emit.assert_called_with | |
| namedtuple('scputimes', 'user system idle') | |
| _OS | |
| cinderclient.client.HTTPClient | |
| factory | |
| whitm | |
| rng.randn | |
| node.Node | |
| XGBModel.fit.__doc__.replace | |
| self.driver._get_selflink_or_name | |
| contract | |
| _DBAPITypeObject | |
| AudioFrame | |
| self.assertFileHandleBehaviorsMatch | |
| hg | |
| LocationInfo | |
| self.chkgraph | |
| sequence | |
| self._test_user_non_text | |
| elasticsearch.mapping_delete | |
| func.my_func | |
| extension.generate_command_environment | |
| JDBCType | |
| testForTimeZone | |
| putils.ProcessExecutionError | |
| e.get_elements | |
| tf.plural_form | |
| redis.watch | |
| RangeExpression | |
| EmrError | |
| PooledPg | |
| collections.namedtuple('foo', 'a b c') | |
| Perm(0, 5, 10, 6, 1)(2, 4, 14, 16, 11) | |
| u.index | |
| SymmetricalLogTransform | |
| self.cmp | |
| CustomType | |
| foo2.foo | |
| xsrfutil.validate_token | |
| de.set | |
| self._assertwarns.__exit__ | |
| LogLogistic | |
| Book.objects.dates | |
| s3_config_query.list_config_service_resources | |
| cls().global_exclude('PKG-INFO').global_exclude('*.egg-info/*').global_exclude('setup.cfg').global_exclude | |
| _Field | |
| raw_output_all.transpose | |
| PyPI.create_path | |
| self.runner.setupEnvironment | |
| date.add | |
| q.to | |
| ExpectedLog | |
| _subgroup_search | |
| configparser.MissingSectionHeaderError | |
| DateTime.DateTime | |
| ui.control.layout().setContentsMargins | |
| ary.reshape | |
| stats.hypergeom.interval | |
| TModel_1_2 | |
| mtext.Text | |
| sRGBColor | |
| xsd.time | |
| self._load_and_dump_with_opened_files | |
| proxy_method_directly | |
| self._assert_encoding | |
| SchemaField | |
| __zypper__(root=root).nolock.xml.call | |
| example_table.add_row | |
| udt | |
| reporter.syntaxError | |
| pat.add_color_stop_rgba | |
| no_header_service.remove | |
| gl.glTranslate | |
| llt | |
| channel.SSHChannel | |
| tasklist | |
| testdir.runpytest_subprocess | |
| np.expand_dims(np.expand_dims(np.expand_dims(P_Y, axis=2), axis=3), axis=4).transpose | |
| self.warnings.__exit__ | |
| module.mock_output | |
| FitsFormat | |
| cephes.gdtrix | |
| o.makeArrayWithCFormat_ | |
| Twython | |
| Perm(0, 16, 7)(1, 10, 11) | |
| AppKit.NSWindowListForContext | |
| self.s0.data.lon.reshape | |
| self.reader.fetch | |
| History | |
| bcpe.Enum | |
| self._acl_add | |
| self.t0.reshape | |
| p_info.add_primer_set | |
| self.with_lc_ctype.__exit__ | |
| win32com.client.gencache.EnsureModule | |
| pubsub.psubscribe | |
| BL | |
| cffi_foo | |
| handler.log_message | |
| np.inner(b, a).transpose | |
| IndexEntry | |
| api_client.getReqSpecCustomFieldDesignValue | |
| implementation.createDocumentType | |
| e.elementary_col_op | |
| cephes.chndtridf | |
| distributions.DiscreteUniformDistribution | |
| ObjectLockConfig | |
| Date10 | |
| description.rindex | |
| np.arange(360).reshape | |
| self.at | |
| np.linspace(0, 5, 9 * 10).reshape | |
| nilrt_ip.set_static_all | |
| controlLayout.setContentsMargins | |
| u.unlink_user_account | |
| m2.dispatch.before_insert | |
| PGPUID.new | |
| m.serialize | |
| cftime_date_type | |
| cairo.TextExtents | |
| Credentials | |
| self._download_webpage | |
| special.betainc | |
| git | |
| draw.ellipsoid | |
| combine_lists | |
| worktree_data['branch'].replace | |
| fibmsg.sql_schema().unique_index | |
| StrStopField | |
| combine_values | |
| glColor3f | |
| get_frame_data | |
| p.immediate_execute_command | |
| get_spectrogram | |
| mock.call | |
| img.transpose | |
| d.insert | |
| self.sc.obsgeoloc.reshape | |
| pg.StringProperty | |
| supervisord.set_procattr | |
| v | |
| Column | |
| ops.mv_column | |
| Skellam | |
| test_shift | |
| V.transpose | |
| z_ref.dimshuffle | |
| cephes.nrdtrisd | |
| np.arange(72).reshape | |
| t.set | |
| mqttc.connect | |
| array.x.layout.argsort | |
| SplitResult | |
| np.arange(3 * 4 * 5, dtype=config.floatX).reshape | |
| If | |
| self.translations.ldpgettext | |
| url.replace | |
| color.getRed_green_blue_alpha_ | |
| NSGetInformationalAlertPanel | |
| self._test_create_policy | |
| management.call_command | |
| r1.clip | |
| cephes.chndtrix | |
| self.mixed_warn | |
| redis.mset | |
| mock_deconfigure_scsi_device.assert_called_with | |
| fmt | |
| self.term.get_region | |
| Set | |
| base.Model | |
| monkeygai.set | |
| unittest.mock.call | |
| np.arange(2 ** 4 * 2)[::2].reshape | |
| PolarStereographicBConversion | |
| self._connect_password | |
| data['image'].reshape | |
| self.conn.session.set_credentials | |
| db.rename_column | |
| _version_info | |
| cephes.obl_ang1 | |
| MyTuple | |
| stats.beta | |
| _combine_regex | |
| jpype.java.sql.Time | |
| DatetimeProlepticGregorian | |
| self.errorPage | |
| solar_term | |
| kr.set_password | |
| environ_getter | |
| wigner_6j | |
| elliprd | |
| self._ui.configbool | |
| _kernel32.CreateEventW | |
| self.proto._getKey | |
| g.SetCellValue | |
| glRotatef | |
| rec.__exit__ | |
| np.arange(1.0, 4 * 5 * 7 + 1).reshape | |
| ts.utc | |
| self.networkops.set_vswitch_port_vlan_id | |
| self.pidfile.__exit__ | |
| make_path | |
| np.arange(3 * 4 * 5).reshape | |
| self._test_list_quota | |
| self._set_process_return_value | |
| ImportlabModule | |
| AppKit.NSGetWindowServerMemory | |
| self._test_db_opt | |
| Perm(0, 10, 17, 12, 3)(1, 6, 11, 7, 2)(4, 5, 16, 18, 8) | |
| mock_logger.warning.assert_called_with | |
| pdep_manager._set | |
| _ContentLength | |
| rgb_pixel | |
| self.prepare_command | |
| dc.DrawText | |
| gdb | |
| simple | |
| FontInfo | |
| helper.__exit__ | |
| entry.AddCategory | |
| self.s1.obstime.reshape | |
| entity.replace | |
| _TABLE_FORMAT.format | |
| randn | |
| np.array([8.5], dtype=np.float32).reshape | |
| tenacity.Future.construct | |
| SCons.Scanner.ClassicCPP | |
| _traffic_ctl | |
| EnumStr | |
| six.MovedAttribute | |
| self.bw.summarize | |
| update.delete | |
| np.array([[1, 1, 2, 2]], dtype=np.float32).reshape | |
| self._add_hadoop_bin_for_envvar | |
| qs1.intersection(qs1).values | |
| random_birthday | |
| 'While reading from {0!r}: option {1!r} in section {2!r} already exists'.format | |
| ScrollAction | |
| self.assert_runs_after | |
| ax1.text | |
| r.geohash | |
| redis.setrange | |
| self.api.remote_add | |
| upload.transmit | |
| self.build_word_list | |
| client.Processor.tokenCreate | |
| self.keyring.set_password | |
| nfa.add_transition | |
| FormParser | |
| JSONResponseError | |
| special.nbdtrc | |
| error.ProcessTerminated | |
| self.setGeometry | |
| StringArgument | |
| set_vswitch.assert_called_with | |
| a.get_connection | |
| repo.add | |
| context.config_loader.get | |
| WFSensorConfig | |
| Gaussian1D | |
| Literals | |
| group.revoke | |
| self.conn.sendGlobalRequest | |
| '{0:12} {1:45} {2}'.format | |
| converts | |
| op.runModalForDirectory_file_types_ | |
| bde.DocumentPatchedEvent | |
| poster.encode.encode_file_header | |
| self.instance.A.add | |
| factory.Maybe | |
| CustomUser._default_manager.create_user | |
| res.smoothed_state_autocovariance(-2, extend_kwargs=extend_kwargs1).transpose | |
| self.reader.__exit__ | |
| self.checkFlags | |
| np.ones(1 * 4 * 8 * 9).reshape | |
| mock.assert_called_with | |
| Perm(0, 2, 8, 9, 4) | |
| self.reference.rename_column_references | |
| QubitBra | |
| wx.ImageList | |
| icol.index.read_indices | |
| KafkaProtocol.encode_consumer_metadata_request | |
| AutosummaryEntry | |
| dbfn.add_field | |
| gdata.gauth.OAuthRsaToken | |
| r.lrange | |
| rows[0].set_cell | |
| main | |
| R.transpose | |
| sqlite.Timestamp | |
| power_representation | |
| func3 | |
| tag.objects.set | |
| mode_has | |
| house.addRect | |
| fragments_reported[0].replace | |
| netscaler.servicegroup_server_exists | |
| self.pamd.get | |
| g.vs | |
| pdf.set_font | |
| cephes.nctdtr | |
| SSHCiphers | |
| qs.order_by | |
| A.add_edge | |
| dut.api('routemaps').default | |
| torch.unsqueeze(R2D.conv1.weight.data, dim=2).repeat | |
| APIError | |
| gen_notification_entry | |
| attrgetter | |
| stor.VOptMedia.bld | |
| self.vboxlayout1.setContentsMargins | |
| env.__exit__ | |
| AliyunRequestSignerAlgorithmV1_0 | |
| row_1.set_cell | |
| self.host.query_gc | |
| clip | |
| IntUniformDistribution | |
| moved | |
| srml.read_srml_month_from_solardat | |
| otConverters.NameID | |
| array([], dtype=int32).reshape | |
| Rect | |
| self.accumulate | |
| eh.handle_exception | |
| operation.database_backwards | |
| float_frame._set_value | |
| Perm(0, 11, 8) | |
| torch.nn.Embedding | |
| Perm(19)(0, 6, 2)(3, 5, 11)(4, 10, 7)(8, 14, 17)(9, 16, 12) | |
| StrLenField | |
| self.get_resources_for_api_version | |
| PreciseDiff | |
| ifaddrmsg.sql_schema().unique_index | |
| logging.info | |
| ColumnInfo | |
| gcal2jd | |
| client.ServerFingerprintMismatch | |
| TestFlag | |
| Sub3Block | |
| mod['design'].transpose | |
| self.d | |
| win32event.CreateEvent | |
| redisB.delete | |
| elasticsearch.mapping_get | |
| bf.set('u8', 8, 254).overflow('fail').incrby('u8', 8, 2).incrby | |
| self.printResult | |
| L.InceptionBN | |
| canvas.setFillColorRGB | |
| tf.errors.FailedPreconditionError | |
| tmp.join | |
| self.cls._get_path | |
| QColor.fromRgb | |
| self._test_encoding | |
| qlognormal_gen | |
| np.arange(60).reshape | |
| pool.execute | |
| ATextResult | |
| call_command | |
| oscillatory_network_1.simulate | |
| xsrfutil.generate_token | |
| np.arange(120, dtype='i4').reshape | |
| self._test_compressor | |
| circ.set_color | |
| tempfile.mktemp | |
| draw.matte | |
| glob_many | |
| join | |
| sqla.exc.DBAPIError | |
| mtype.__setattr__ | |
| parser.set | |
| MegaFontRendererFactory | |
| Sequence | |
| self.ec2.modify_network_interface_attribute | |
| TPickleV8 | |
| J2.matrix_element | |
| canvas.setStrokeColorRGB | |
| basetemp(testdir).join | |
| settings.Settings | |
| f2.append_data | |
| x._delete | |
| client.cluster_path | |
| otConverters.UInt8 | |
| aiohttp.BasicAuth | |
| sub.punsubscribe | |
| painter.drawRect | |
| api_client.getTestCaseCustomFieldTestPlanDesignValue | |
| ParameterizingString | |
| zipf_rv | |
| Bug | |
| message_trace | |
| qemu_img.make_image | |
| Gtk.check_version | |
| ConfigOptionParser.create_path | |
| s3 | |
| show_message | |
| open | |
| dism.capability_removed | |
| m_cache.set.assert_called_once_with | |
| _dbus_bindings.SignalMessage | |
| Wigner9j | |
| a.set | |
| _keep | |
| ellipsoid_stats | |
| request._nr_wait_function_trace.__exit__ | |
| lazy_ngettext | |
| Predictions | |
| r.sdiffstore | |
| FunctionMatrix | |
| create | |
| DerivedII | |
| RGB | |
| TPickle1 | |
| cache_id.replace | |
| self.connect | |
| exit_dialog.text | |
| self.alloc_w_dep_tens.dimshuffle | |
| error.text | |
| self._assert_adds_steps_one_at_a_time | |
| CoreText.CTFontCreateWithNameAndOptions | |
| gamma.dimshuffle | |
| x.resize | |
| cephes.lpmv | |
| deploy_image_to_vm.assert_called_with | |
| self._set_position | |
| self.driver.ex_share_ip | |
| client.object.patch.add_link | |
| normalize_raises | |
| limited_range | |
| sa_exceptions.DBAPIError | |
| ax[1].plot | |
| self.mm_builder.allow_transition | |
| urlp.convert | |
| redis.command_getkeys | |
| self.getdelimited | |
| models.Gaussian1D | |
| obj.oneway | |
| _CacheControl | |
| url.child | |
| fig.canvas.manager.toolbar.add_tool | |
| multipart.copy_part_from_key | |
| b.dimshuffle | |
| ask_yes_no | |
| Cocoa.NSColor.colorWithCalibratedRed_green_blue_alpha_ | |
| cache_store_mock.assert_called_once_with | |
| check_deprecated | |
| np.array([0, 0.2, 0.4, 0.6, 0.8, 1], dtype=np.float32).reshape | |
| api_config.LimitDefinition | |
| getEncoding | |
| delete_nic.assert_called_once_with | |
| dms | |
| extensions.MicroAverage | |
| ObsoleteAttr | |
| prepend_extension | |
| Fieldset | |
| self.assertEqual | |
| Publisher.objects.annotate(num_books=Count('book')).exclude(num_books__lt=F('num_awards') / 2).order_by('name').values | |
| match.group | |
| self.driver.Time | |
| self.t2.reshape | |
| PCMYKColor | |
| self.Event | |
| self._check_ld | |
| userdb.addUser | |
| np.logspace | |
| update.update | |
| cli_ctx.config.get | |
| api_client.getTestPlanCustomFieldDesignValue | |
| cfg.print_stdout | |
| crypt | |
| conv_utils.normalize_tuple | |
| dbapi2.Timestamp | |
| LDAPControl | |
| Image | |
| c.__init__ | |
| text_wrapper.fill(signature).replace | |
| grafana_datasource._get_json_data | |
| context_manager.__exit__ | |
| myconn.Date | |
| pubsub.subscribe | |
| UniformFloatHyperparameter | |
| c.drawString | |
| tr.setScale | |
| should_fail_under | |
| ReadStringsFromPubSub | |
| CoreFoundation.CFPreferencesGetAppIntegerValue | |
| self.api.initStep | |
| apipkg.AliasModule | |
| ctx.set_source_rgb | |
| namedtuple('vmem', 'total available percent used free') | |
| self.path.replace | |
| jp_fetch | |
| float_tensor.permute | |
| WignerD | |
| table.read | |
| assocs | |
| td.api.run_schedule.assert_called_with | |
| _test_string | |
| logger.warning | |
| ErrorPage | |
| path_set | |
| m2.add_transition | |
| bulid_callback | |
| DateTimeTZRange | |
| QConicalGradient | |
| con.xid | |
| CG | |
| Foundation.NSNetService.alloc().initWithDomain_type_name_port_ | |
| subdate | |
| cephes.nctdtrinc | |
| luigi.configuration.get_config().get | |
| test_date | |
| AbelianGroup | |
| torch.unsqueeze(R2Dlayers[s]._modules[str(k)].conv1.weight.data, dim=2).repeat | |
| Scenario | |
| self.locales.loadLocale | |
| s.should_call('startswith').with_args | |
| wx.Bitmap | |
| Ynm | |
| ax2.plot | |
| r.georadiusbymember | |
| p | |
| field.from_db_value | |
| np.array([1, 0, 1, 0, 1, 0, 0, 0]).reshape | |
| tmpdir.ensure | |
| fc.ITL | |
| self.expected.reshape | |
| ctx1.__aexit__ | |
| psycopg2.extensions.Notify | |
| b.diagonal | |
| JointDistribution | |
| syncpr | |
| az_config.get | |
| self.__exit__ | |
| dp1.c.transpose | |
| self.pamd.remove_module_arguments | |
| r.zremrangebylex | |
| obj | |
| libcloud_compute.import_key_pair | |
| length | |
| cephes.ncfdtr | |
| self.assert_pack | |
| df.pivot | |
| core.LambdaCDM | |
| virt.network_defined | |
| Perm(0, 4, 9, 14, 5) | |
| self.run_python | |
| SignalMessage | |
| linux_lvm.lvextend | |
| register_encryption_alg | |
| search.DateFacet('datefield').add_range | |
| s.add_document | |
| DimensionalityError | |
| cache.register_backend | |
| self.set_attributes | |
| PngImagePlugin.iTXt | |
| Perm(7) | |
| type(datetime_obj) | |
| expand_rule | |
| htpasswd.user_exists | |
| (mul_result / norm_value.clamp(min=tiny_value_of_dtype(norm_value.dtype))).permute | |
| np.arange(3 * 5 * 2).reshape | |
| aic | |
| GIMarshallingTests.gvalue_flat_array_round_trip | |
| self.form.iter | |
| Tuple(0, 1, 2, 3, 4).index | |
| PaneInfo | |
| self.repository_remote_name.replace | |
| config.SetOption | |
| obj.clip_rect | |
| self.conf.set | |
| UrlHandler | |
| ospf.remove_network | |
| Perm(0, 2, 3)(1, 8, 4)(5, 7, 9) | |
| Employee.objects.annotate(ntile=Window(expression=Ntile(num_buckets=4), order_by=F('salary').desc())).order_by | |
| timezone.datetime | |
| deprecate | |
| T.arange | |
| CustomCollection | |
| np.mgrid[0:2, 0:2, 0:2].reshape(3, 8).transpose().reshape | |
| ImmutableDenseNDimArray(range(24)).reshape | |
| _aset | |
| haar_like_feature_coord | |
| np.array([[6, 6.333333, 6.66666, 7], [7.333333, 7.666666, 8, 8.333333], [8.666666, 9, 9.3333333, 9.666666], [10, 10.333333, 10.666666, 11]], dtype=np.float32).reshape | |
| redis.zincrby | |
| td.api.swap_table.assert_called_with | |
| ssh._expand_authorized_keys_path | |
| Downloader.create_path | |
| dns.Record_MX | |
| c.coords | |
| class_b | |
| context._assert_ | |
| Unique | |
| self.s3.reshape | |
| y.reshape | |
| update.present | |
| draw.text | |
| redis.touch | |
| data.insert | |
| numpy.arange(42, dtype=numpy.float32).reshape | |
| inventory_module.inventory.set_variable | |
| format_byte_size | |
| r.geodist | |
| etl.fromxml | |
| self.rg.noncentral_chisquare | |
| self._make_tag_path | |
| nursery.cancel_scope.__exit__ | |
| dep_manager._set | |
| Remote | |
| self.makedirs | |
| self.inflections.uncountable | |
| self.rg.vonmises | |
| MercatorAConversion | |
| np.array([sum(x[:i + 1]) for i in range(len(x))]).reshape | |
| image.transpose | |
| r.pfmerge | |
| r._task_stderr_path | |
| td.api.update_expire.assert_called_with | |
| c.crypto_secretbox_open | |
| self.assert_context | |
| Perm(3) | |
| delete_snapmirror.assert_called_with | |
| W.dimshuffle | |
| self._assert_encoding_detected | |
| ax.hlines | |
| supports_proxies | |
| iso | |
| asyncpg.Line | |
| compat_struct_pack | |
| auth_set | |
| sleepLambda | |
| '{0:12} {1:<22} {2:<8} {3:<8} {4:<5} {5:<8}'.format | |
| etag_property | |
| np.arange(54).reshape | |
| np.arange(8 ** 3).reshape | |
| test_config.set | |
| pyomo.opt.check_available_solvers | |
| Foundation.NSLocalizedStringFromTable | |
| InstalledDistribution.create_path | |
| '{:>10} {:>20} {:>10}'.format | |
| fmt.format | |
| Q.transpose | |
| locales.getLocale | |
| self.match | |
| Perm(0, 7, 13)(1, 12, 9)(2, 8, 4) | |
| libcloud_dns.record_present | |
| DeathForm | |
| mock_attr.abc.assert_called_once_with | |
| svgData.replace | |
| glNormal3f | |
| _PageDesc | |
| self.assertSchedule | |
| res.smoothed_state_autocovariance(-3, end=mod_oos.nobs - 2, extend_kwargs=extend_kwargs).transpose | |
| stub.add_client_error | |
| qRgba | |
| times.date_type | |
| frontwheel.set_color | |
| Class3Arg | |
| self.s1.location.reshape | |
| MethodTest.OptionalParams | |
| from_origin | |
| Levy | |
| o.makeArrayWithArguments_ | |
| Convolution2D | |
| worksheet2.autofilter | |
| c.ignore | |
| backwheel.set_color | |
| spwd.addUser | |
| formatter.format | |
| u'# {:14} {:<21} {:<15s}'.format | |
| np.arange(64).reshape | |
| hg.update | |
| update_xauth | |
| genpy.generator.string_serializer_generator | |
| ellipse | |
| ctx.call | |
| MockTransaction | |
| script_app().auth.implicit | |
| email_message.attach | |
| QtCore.QRectF | |
| length._p_resolveConflict | |
| at | |
| Reporter | |
| self.SetCellSize | |
| LinkEvaluator.create_path | |
| previous_rule.matches | |
| v0 | |
| m.trigger | |
| '{:9s} {:>6s} {:>6s} {:>6s}'.format | |
| kwargs['url'].replace | |
| self.set_attribute | |
| _module_import_error | |
| conn.describe_activity_type | |
| safeCreateWindowExA | |
| Publisher.objects.annotate(num_books=Count('book')).filter(num_awards__gt=2 * F('num_books')).order_by('name').values | |
| a.reshape(2, 2, 3, 2).transpose | |
| pack_asn1 | |
| x509.AuthorityKeyIdentifier | |
| np.arange(3 * 2 * 4).reshape | |
| self.translations.dnpgettext | |
| pytest.param | |
| conv_utils.deconv_length | |
| intervalMembership | |
| progress.control | |
| GuaranteedThroughputProbabilisticSampler | |
| get_catkin_view | |
| np.arange(matrix_ct * 2 * 4, dtype=np.float32).reshape | |
| content1.sort | |
| dt_time | |
| rf.open | |
| self.wtest | |
| Perm(0, 2, 12, 19, 14) | |
| stdin.channel.make_x11_forwarding_request | |
| sasl_mechanisms.Plain | |
| self.build_device | |
| position_angle | |
| key.replace | |
| worksheet.write | |
| '{0:^15}{1:^15}{2:^15}{3:^15}{4:^15}'.format | |
| Perm(0, 3, 4) | |
| bp.IOSlot.bld | |
| XySeriesData | |
| c.addPyProperty | |
| Angle.dms2deg | |
| self.translations.ngettext | |
| '{0:>{1}}'.format | |
| self._shell.build_module_command | |
| ImageFilter.UnsharpMask | |
| KmediansTestTemplates.templateClusterAllocationTheSameObjects | |
| infos.add | |
| time | |
| VerifierDB.makeVerifier | |
| self.block_device_mapping.startElement | |
| device.name.replace | |
| _path | |
| _build_instance_metadata_url | |
| Employee.objects.annotate(is_point_of_contact=Exists(Company.objects.filter(point_of_contact=OuterRef('pk'))), is_not_point_of_contact=~Exists(Company.objects.filter(point_of_contact=OuterRef('pk'))), is_ceo_of_small_company=Exists(Company.objects.filter(num_employees__lt=200, ceo=OuterRef('pk'))), is_ceo_small_2=~~Exists(Company.objects.filter(num_employees__lt=200, ceo=OuterRef('pk'))), largest_company=Subquery(Company.objects.order_by('-num_employees').filter(Q(ceo=OuterRef('pk')) | Q(point_of_contact=OuterRef('pk'))).values('name')[:1], output_field=CharField())).values | |
| PrimePoint | |
| self.checkRule | |
| cls.from_face_pos_level | |
| bottom_layout.setContentsMargins | |
| mock_sys.excepthook | |
| df.insert | |
| PredictionExplanations | |
| self.domimpl.createDocument | |
| AuthenticationRecord | |
| make_message | |
| state._make_or_expr | |
| datetime_helpers.DatetimeWithNanoseconds | |
| decorated_func | |
| salt.utils.versions.compare | |
| Country | |
| self.service_connection.describe_stack_resources | |
| sub.execute_pubsub | |
| table.addRow | |
| cfg.dget | |
| cmd_msbuild | |
| file_replace | |
| OSUtils().open_file_chunk_reader | |
| Employee.objects.annotate(sum=Window(expression=Sum('salary'), partition_by='age', order_by=[F('age').asc()], frame=ValueRange(start=None, end=None))).order_by | |
| irradiance.perez | |
| width_aware_slice | |
| client.GoogleCredentials | |
| loads | |
| self.create_superuser | |
| js_to_py_type(type_object['value']).replace | |
| s['TEST'].set | |
| wintypes.BYTE * 8 | |
| Perm(0, 10, 7)(1, 5, 6) | |
| api_client.getRequirementCustomFieldDesignValue | |
| self.host.XenAPI.Session().xenapi.pool.join_force.assert_called_with | |
| np.array([0, 1], dtype=np.float32).reshape | |
| self._test_create_rule | |
| self.ui.setconfig | |
| a.reshape(2, 2, 3, 2).transpose(0, 2, 1, 3).reshape | |
| self.setconfig | |
| LpVariable | |
| np.arange(256).reshape | |
| absl.flags.DEFINE_string | |
| self.s0.lat.reshape | |
| self.f | |
| Perm(1, 4, 5)(2, 9, 10)(3, 14, 6) | |
| _lookup_by_id_or_name_factory | |
| img.dimshuffle | |
| random_value_array(np.nan, 1.0)(2 * 3 * 4).reshape | |
| irradiance.clearness_index | |
| holzer | |
| patch_request.remove_item | |
| np.arange(2 * 4 * 4).reshape | |
| g.fwd | |
| np.arange(48 * 6).reshape | |
| ServicePort | |
| AppKit.NSDirectionalEdgeInsetsMake | |
| view.get_list | |
| delete_period_abs.format | |
| cls._cm.__exit__ | |
| self.run_and_get_cluster | |
| type_ | |
| self.create_user | |
| hqic | |
| Deployment.create_from_learning_model | |
| collect_data_files | |
| StubOptions | |
| Gamma | |
| self.s0.data.lat.reshape | |
| stem.connection.CookieAuthRejected | |
| self.translations.dpgettext | |
| sqltypes.Enum | |
| function_with_non_pep_0484_annotation | |
| smtp.sendmail | |
| pip.set_return_tuple | |
| fakes.FakeVolumeSnapshot | |
| pypi_rc.set | |
| AlignIO.convert | |
| pillar._external_pillar_data | |
| self.wait_until_element_is | |
| current_rule.prev.matches | |
| PowerFunctionDistribution | |
| format_message | |
| static.MultipleRangeStaticProducer | |
| PlanimeterTest.polyline.TestEdge | |
| hdfs.du | |
| cmd_output_b | |
| c.set | |
| headers.add | |
| (S - M).transpose | |
| TempDirectory.create_path | |
| Config.set | |
| c.nworkers_changed | |
| BITBUCKET.delete_default_reviewer | |
| pg.QtCore.QRect | |
| self.driver.ex_add_server_firewall_policy | |
| A.dimshuffle | |
| Graph.Watts_Strogatz | |
| self.s1.reshape | |
| DatetimeNoLeap | |
| _text1.replace | |
| mpa | |
| flags.DEFINE_float | |
| er.error | |
| redis.geodist | |
| QualityComponent | |
| chan.change_terminal_size | |
| Gif | |
| ch_mean.reshape | |
| Perm(0, 9, 6) | |
| self.linuxscsi.scan_iscsi | |
| self.implementation().createDocument | |
| conn.create_cluster_parameter_group | |
| experiment.append_tags | |
| LabelBase | |
| g.election | |
| BetaBinomial | |
| some_func | |
| HttpRequestBuilder | |
| proxy.ReverseProxyResource | |
| current_transaction().__exit__ | |
| render | |
| _determine_eq_order | |
| cairo.RectangleInt | |
| ErrorCode | |
| self.cf.register_option | |
| canvas.create_line | |
| self.agent._computeHostValue | |
| cephes.pro_rad1_cv | |
| self.coll.map_add | |
| current_rule.next.matches | |
| command.to_model | |
| self.remove_auto_open_files | |
| np.arange(2 * 3 * 4).reshape | |
| SyncTestTemplates.templateVisualizerNoFailures | |
| tsriov._check_and_filter_vioses | |
| splat_sum | |
| self.client.extend_list | |
| cephes.gdtrib | |
| phoenixdb.Time | |
| hyp2f3 | |
| term.link | |
| encode_endian | |
| DummyFormat | |
| row_2.set_cell | |
| c.crypto_box_afternm | |
| Perm(0, 2, 12, 19, 14)(1, 7, 18, 15, 5)(3, 8, 13, 9, 4) | |
| args2cmdline | |
| stats.trapz.cdf | |
| firewalld.add_port_fwd | |
| IntegralTransformError | |
| r.bitcount | |
| class_probs.dimshuffle | |
| self.get_options | |
| np.base_repr | |
| np.arange(2 * 7 * 5, dtype=np.int64).reshape | |
| self.conn._on_close | |
| CC | |
| self._make_one(collection).where | |
| np.arange(2 * 3 * 4 * 5).reshape | |
| extensionLayout.setContentsMargins | |
| config.set | |
| L.Inception | |
| runner._simulate_jobconf_for_step | |
| list_items | |
| CommonMixedCaseForeignKeys.objects.values | |
| scope.__exit__ | |
| binom.logpmf | |
| version_info_t | |
| server_conn.export_keying_material | |
| SQLAlchemyEnumType | |
| expected.reshape | |
| create_environment_hook | |
| d | |
| theano.compile.get_mode(self.mode).excluding | |
| repo.ui.setconfig | |
| self.templateCfTreeLeafIntegrity | |
| crop | |
| s.build_url | |
| pvl.__setslice__ | |
| add_private_dict_entry | |
| obj.manyargs | |
| sm.distributions.zipoisson.ppf | |
| self.rg.normal | |
| self.con.execute | |
| _ContentDisposition | |
| _random_binary_string_matrix | |
| regex.search('((a|b(?1)c){3,5})', 'baaaaca').group | |
| listview.scroll | |
| tsocket.socket | |
| crypto.X509Extension | |
| x_zero_point.reshape | |
| ds.transpose | |
| zope.deferredimport.deprecatedFrom | |
| make_array | |
| ellipsoid | |
| functions.SnapToGrid | |
| timelib.julian_date | |
| Link.create_path | |
| ApiV2 | |
| balanced_reduce | |
| SubRipTime | |
| ureg.check | |
| self.client.connect | |
| d.iterancestors | |
| text.tag_add | |
| combine_cmds | |
| pg8000.Time | |
| AppliedPTransform | |
| normalize_url | |
| last_hidden.permute | |
| plt.subplots_adjust | |
| x.reshape | |
| models.RotateNative2Celestial | |
| self.check_markdown | |
| NotFound | |
| TargetOne().dispatch.event_five | |
| self._stream | |
| Perm(0, 1, 2)(3, 5, 7)(4, 6, 8) | |
| appellf1 | |
| client.call | |
| FileUpload | |
| cmd_auto.Auto._run_callback | |
| AppliedUndef | |
| self.mibInstrumController.mibBuilder.loadModules | |
| keychain.set_default_keychain | |
| node.inputs[0].dimshuffle | |
| ddns.update | |
| Perm(0, 7, 2) | |
| assert_bad_type | |
| self.assertInTabs | |
| fig_test.add_subplot | |
| dbapi2.Time | |
| self.s2.obstime.reshape | |
| cephes.radian | |
| stats.geninvgauss.pdf | |
| NSMakeRect | |
| 'http://{}:{}@{}:9000/path?query#frag'.format | |
| self._test_process_query_batch_item | |
| m3.scale | |
| query | |
| view4.get_list | |
| layout.translate | |
| self.bounds.adjusted | |
| Application | |
| np.arange(24, dtype='c16').reshape | |
| reporter.write | |
| RequestField | |
| bf.set('u8', 4, 1).get('u16', 0).set | |
| get | |
| GL.glColor3f | |
| self._test_translate | |
| oracledb.Timestamp | |
| AstInterpreter | |
| ClearColor | |
| UploadData | |
| ttb.euler2mat | |
| web_app().auth.implicit | |
| self.pamd.add_module_arguments | |
| getattr(r, method) | |
| child_trace_2.__exit__ | |
| zfs.release | |
| self.increment_counter | |
| MIMEText | |
| PresentationPart | |
| conn.register_workflow_type | |
| self.lam | |
| doctest.DocFileSuite | |
| crypt.gen_keys | |
| stats2.log_request | |
| self.s0.reshape | |
| dt | |
| self.normpath | |
| webcolors.PercentRGB | |
| Slider | |
| _get_expected_instance_ttx | |
| FrameworkDependency | |
| mock_attr | |
| creds._context.acquire_token_with_client_credentials.assert_called_with | |
| a._data.choose | |
| self._devset_scroll | |
| sqlite.Date | |
| run_test | |
| np.arange(12).reshape | |
| sess.query(User).select_entity_from(sel).join | |
| SWFFormat | |
| Perm(0, 9, 6)(1, 3, 11) | |
| DatabaseError | |
| self.channel.exchange_bind | |
| flag.set_color | |
| MyTimedelta | |
| self.set_password | |
| Worker | |
| m.IV | |
| r.geopos | |
| redis.delete | |
| a.trait_metadata | |
| self._topLayout.setContentsMargins | |
| TokenCredentials | |
| Publisher.objects.annotate(earliest_book=Min('book__pubdate')).exclude(earliest_book=None).order_by('earliest_book').values | |
| axes.SeriesAxis | |
| conf.callable_pyobject | |
| tracker.add_skip | |
| inertia | |
| self._get_cluster_config | |
| table.insert | |
| exit | |
| Angle | |
| pattern.curve_to | |
| x.title.replace | |
| self.path_decoration.addRect | |
| self._run | |
| dependencies.add | |
| Ellipsoid | |
| np.random.randn | |
| pdfdoc.PDFPageLabel | |
| wx.VideoMode | |
| rtmsg.sql_schema().push('route_id', 'TEXT UNIQUE').push('gc_mark', 'INTEGER').unique_index | |
| Perm(0, 4, 9, 14, 5)(1, 3, 13, 15, 10)(2, 8, 19, 16, 6) | |
| _impl_log.LogDriver | |
| reactors.Reactor | |
| self._operations_stub_internal.__exit__ | |
| subtest | |
| self.state.add_transition_any | |
| VideoFrame | |
| n | |
| api_client.createTestSuite | |
| v.stringByAppendingFormat_ | |
| w.dimshuffle | |
| pytester.inline_run | |
| Perm(0, 3, 4)(1, 8, 10) | |
| a.iterdescendants | |
| rand | |
| self.service_connection.create_hosted_zone | |
| Perm(0, 5, 6, 7, 2) | |
| httplib2.ProxyInfo | |
| ColorTriplet | |
| ntuple_range | |
| lambdify((x, y, z), ITE(x, y, z)) | |
| np.arange(24, dtype='f8').reshape | |
| kmedoids_test_template.templateClusterAllocationTheSameObjects | |
| self.storage._chown | |
| loader.discover | |
| cephes.bdtrc | |
| _d | |
| m.declaredInputName | |
| perspective.callRemote | |
| execute | |
| LambertAzumuthalEqualAreaConversion | |
| install_req_from_editable.create_path | |
| self.session.set_file_logger | |
| registerFontFamily | |
| runner.startReactor | |
| stats.gamma.stats | |
| NotesSlidePart | |
| CPLE_BaseError | |
| boundary | |
| ds.get_private_item | |
| fmtStr.format | |
| Quartz.CGRectMake | |
| self._diff_update_and_compare | |
| np.arange(60.0).reshape | |
| ff | |
| deprecated_param | |
| instance.get_tile | |
| docformatter.is_in_range | |
| self.dataset_ht.add_dimension | |
| fakes.make_fake_server | |
| _NameTable | |
| _rle_decode_frame | |
| cache._base_set | |
| glRotate | |
| idx.get_slice_bound | |
| netscaler.servicegroup_server_up | |
| x[i].transpose | |
| Perm(0, 2, 3)(1, 8, 4) | |
| Item.objects.exclude(name='two').extra(select={'foo': '%s'}, select_params=(1,)).values | |
| _process_setting | |
| ProcessLogStderrEvent | |
| at(a=1) | |
| ParseFatalException | |
| gen_ol(impl7) | |
| self.timed_request | |
| source.ensure | |
| self.cli.grant_privilege | |
| self.jumper.add_transition | |
| ax.arrow | |
| self.http.add_credentials | |
| api_client.getTestCaseCustomFieldExecutionValue | |
| go.set | |
| RegexValidator | |
| elements._document_text_coercion | |
| numpy.arange(2 * 3 * 4 * 4, dtype=numpy.float32).reshape | |
| ourtestdir.runpytest | |
| Tab | |
| flexmock(Foo).should_receive('bar').with_args | |
| myTeamsPotentialAction2.addInput | |
| flexmock(Foo).should_receive('__iter__').and_yield | |
| self.process.__exit__ | |
| np.arange(40).reshape | |
| self.list.update | |
| table.removeNames | |
| _document_text_coercion | |
| self.grammarbox.tag_add | |
| self.stdin_swap.__exit__ | |
| algo.verify | |
| f.cell | |
| _expand_keys | |
| double_add | |
| unpack_url.create_path | |
| DriverInfo | |
| self.ops.datetime_trunc_sql | |
| change_signature.ArgumentAdder | |
| a.elementary_col_op | |
| gl.glBlendColor | |
| indexedarray1.argsort | |
| wx.TextEntryDialog | |
| apache.useradd | |
| creds._context.acquire_token_with_username_password.assert_called_with | |
| self.pamd.has_rule | |
| AVFoundation.AVAudioMake3DAngularOrientation | |
| datastore.DatastorePath | |
| SubscriptionType | |
| bezier_curve | |
| otConverters.GlyphID | |
| self.connection.create_pipeline | |
| np.array([0, 0.1, 0.5, 0.9, 1], dtype=np.float32).reshape | |
| self._fstates.contains_none | |
| CountMetric | |
| val[:-1].replace | |
| datapath | |
| conn.deprecate_activity_type.when.called_with | |
| cls.classes | |
| mn_trial.suggest_uniform | |
| BadNDDataSubclass | |
| emitter.emit_lines | |
| Xs.dimshuffle | |
| res[0].reshape | |
| _make_url | |
| settings.change_setting | |
| table.hopping | |
| self._make_one | |
| self.TryListAttributeVariations | |
| np.linspace(0, 10, 2 * 5 * 15).reshape | |
| _d_and_s | |
| BooleanFunction | |
| exog.insert | |
| QSqlRelation | |
| raw.set | |
| p.check | |
| synthetic_pipeline.get_synthetic_sdf_step | |
| sy.MatrixSymbol | |
| NegativeBinomial | |
| m1.translate | |
| fits.Card | |
| dns.Record_WKS | |
| self.c._on_basic_return | |
| y.dimshuffle | |
| Bbox.from_bounds | |
| func | |
| read | |
| DrawingArea | |
| yaml.reader.ReaderError | |
| cthread.key_partition | |
| env.require_version_min | |
| repo.get_store().should_receive('get').and_return | |
| SearchResult | |
| jd | |
| self.t2.jd1.reshape | |
| numpy.random.randint(low, high, size=33 * 31 * 3, dtype='i4').reshape | |
| nx.connected_watts_strogatz_graph | |
| np.arange(8).reshape | |
| path.AddCircle | |
| CoreFoundation.CFStringCreateWithCharacters | |
| self._smutclient.couple_nic_to_vswitch | |
| extension.create_package_script | |
| cairo.Glyph | |
| virt._gen_net_xml | |
| Quartz.CATransform3DMakeTranslation | |
| shell.git | |
| Share | |
| self.__create_single_branch | |
| operator.itemgetter | |
| self.cl.set_basics | |
| m._venus_magnitude | |
| APoint | |
| page_iterator._do_nothing_page_start | |
| template.replace | |
| colbars.reshape | |
| self.base_overwrite_qr | |
| Choices | |
| self.norm | |
| glMapGrid2f | |
| Weibull | |
| sensitive_post_parameters | |
| r.bitop | |
| obj.TestMethod | |
| conn.upload_server_cert | |
| FileApiBase | |
| conn.modify_lb_attribute | |
| cephes.nctdtridf | |
| CustomKetMultipleLabels | |
| min | |
| LinearBucket | |
| gen_ol(impl8) | |
| Jigsaw | |
| pyui.widgets.Frame | |
| np.tri | |
| uwsgi.cache_set | |
| fresnel_coefficients | |
| self.fs.join | |
| widget._render_row | |
| stats.genpareto.logsf | |
| self.mock_pidlockfile.__exit__.assert_called_with | |
| service_path | |
| mman.register_alias | |
| fun | |
| self.res.associate_notification_template | |
| CoreText.CTFontCreateWithName | |
| input_spec | |
| random_state.randint | |
| DatetimeJulian | |
| self.scrollarea.setViewportMargins | |
| cephes.mathieu_modcem2 | |
| np.ones(12, dtype=np.float64).reshape | |
| pygit2.Signature | |
| requires_salt_states | |
| self._instance._city_name_matches | |
| x.f | |
| self.rounded_box | |
| replace_extension | |
| cancel.pushbutton | |
| expand_dest | |
| Perm(0, 3, 9)(1, 8, 14)(2, 13, 5) | |
| host.ansible | |
| cmd | |
| s._setup_configuration | |
| plt.text | |
| _DeprecatedBool | |
| lazyimport._loadBundle | |
| USER_CACHE_DIR.create_path | |
| pwd.addUser | |
| self.dmp.match_bitap | |
| self.verticalLayout.setContentsMargins | |
| Inputs | |
| vlarray.read | |
| attr.replace | |
| linux_lvm.lvcreate | |
| mytype4.set_fields | |
| h.encode | |
| 'Shapes: {} - Vertex: {} - Elements: {}'.format | |
| shared._HTTPBinDescription | |
| cephes.bdtrik | |
| notebook.set_cell_metadata | |
| d.reshape | |
| self.gridLayout.setContentsMargins | |
| epub.Link | |
| self.param_uri_for | |
| cmap.getLookupTable | |
| mathieus | |
| PageDescriptor | |
| np.arange(40 * 30 * 2).reshape | |
| '{0:^25}{1:^25}{2:^32}{3}'.format | |
| tree.common_ancestor | |
| cairo.MeshPattern().set_corner_color_rgba | |
| self.send_error | |
| cairo.Rectangle | |
| oscillatory_network.simulate | |
| join_lines | |
| c.splice | |
| np.array([0, 0.25, 0.5, 0.75, 1], dtype=np.float32).reshape | |
| Quartz.CGEventCreateKeyboardEvent | |
| dq | |
| clearsky.ineichen | |
| form.get_value | |
| table._send_changelog | |
| cephes.nctdtrit | |
| gen_simple_logit | |
| self.users.create | |
| Code | |
| into_path | |
| numpy.array(expected).reshape(B, H, W, 2).transpose | |
| make_tb | |
| _DictOf | |
| o.validateValue_forKey_error_ | |
| a.block | |
| hass.components.frontend.async_register_built_in_panel | |
| Perm(0, 1, 2, 3, 4)(5, 6, 7, 8, 9) | |
| mode.including('fast_run').excluding | |
| d.check_all | |
| earthlib.refract | |
| EccPoint | |
| cal.set | |
| DemoRemote | |
| im.permute | |
| catalog.getPluralMessage | |
| cv.detail_AffineBestOf2NearestMatcher | |
| cp.set | |
| time.set | |
| policy.RuleDefault | |
| template.format | |
| call.__exit__ | |
| synthetic_pipeline.SyntheticStep | |
| get_dict | |
| ap.replace | |
| self.s0.lon.reshape | |
| self.sdf_split | |
| Foundation.NSData.alloc().initWithContentsOfFile_options_error_ | |
| self.table_level.setContentsMargins | |
| XBlock | |
| Gaussian2D | |
| job1.tag | |
| arange(6).reshape | |
| fscalars | |
| NodeSize | |
| TransferFunction | |
| self.random.randn(27).reshape | |
| scope.quniform | |
| ReadTimeoutError | |
| volume.endElement | |
| font.appendSFNTName | |
| self._test_attribute_header | |
| jpype.JArray(jpype.JInt, 1) | |
| boto_route53.add_record | |
| Datetime360Day | |
| protocol.PartitionFetchRequest | |
| IPy._checkPrefix | |
| canv.setStrokeColorRGB | |
| np.random.normal | |
| legenp | |
| browser.replace | |
| s.endswith | |
| pi.CacheKey | |
| MyDatetime | |
| h.encrypt | |
| a2.resize | |
| self.check_by_char | |
| np.arange(1.0, 4 * 4 * 7 + 1).reshape | |
| SlideMasterPart | |
| Perm(0, 10, 7) | |
| Tuple | |
| rtc.BeginNumberedBullet | |
| Perm(0, 4, 5, 1) | |
| dism.add_package | |
| self.input_generator.__exit__ | |
| Struct | |
| res.smoothed_state_autocovariance(-1, start=8, end=9).transpose | |
| GL.glClearColor | |
| quniform_gen | |
| json.JSONDecodeError | |
| parent_body.replace('></cms-plugin>', '>CLICK ON LINK1</cms-plugin>', 1).replace | |
| A | |
| self.s3.obsgeoloc.reshape | |
| BetaPrime | |
| DBRef | |
| special.assoc_laguerre | |
| dns.edns.ECSOption | |
| np.array(vs).transpose | |
| conn.request | |
| nn.Conv2d | |
| BaseStoryPart | |
| context.rel_curve_to | |
| wx.Rect | |
| self.setmtime | |
| _Handler | |
| nt('event', 'button inaxes key') | |
| stats.log_request | |
| Range | |
| buffer | |
| _py_stringWidth | |
| widget.render_js_init | |
| cephes.gdtria | |
| cache.set | |
| _tb | |
| pylab.subplot | |
| np.asarray(img).astype('f').transpose | |
| gz.translate | |
| redismod.lrange | |
| ReturnLoggerFactory() | |
| django_testdir.runpytest_subprocess | |
| HPackMagicBitField | |
| elasticsearch.TransportError | |
| self._pack | |
| maxis._make_getset_interval | |
| Scenarios.AddressedUser | |
| self._call_api | |
| obj.Addr | |
| t.iter | |
| super().__init__ | |
| handler.assert_called_with | |
| _make_field_path | |
| config.get_config | |
| tf.app.flags.DEFINE_boolean | |
| self.MyRect | |
| Build | |
| _deprecation.deprecate_param | |
| Quaternion | |
| truck.addEllipse | |
| SequenceComparison | |
| cephes.nbdtrin | |
| mixer.init | |
| cls.tables.get_all | |
| self.scene.setContentsMargins | |
| greendns.getaddrinfo | |
| c.setFillColorRGB | |
| wx.Rect2D | |
| SymSpell | |
| self.assertError | |
| create_custom_qss | |
| Perm(0, 8, 10) | |
| pdfmetrics.stringWidth | |
| connect | |
| Distance | |
| ValidationError | |
| wrap | |
| exceptions.UnsupportedAttribute | |
| beta.dimshuffle | |
| binary_op | |
| self.message.getHeaders | |
| param | |
| support.requires_linux_version | |
| flight.FlightDescriptor.for_path | |
| NVector | |
| self._setUID | |
| mytype.set_fields | |
| pytest.mark.only | |
| ColumnGet | |
| builder.add_squeeze | |
| Timestamp | |
| ospf.add_network | |
| self._short_help | |
| _MoviePicElementCreator | |
| rname.InvalidResourceName.bad_syntax | |
| use_model | |
| QCoreApplication.translate | |
| pygame.Rect | |
| cron.set_special | |
| value.replace | |
| G8NodeDriver | |
| tornado.httputil.ResponseStartLine | |
| Person.objects.all().only | |
| logger.packet | |
| c.get_container | |
| besseljzero | |
| _option_set.OptionGroup | |
| type.Overloaded[str, bool, int] | |
| self.encode | |
| x[:, :, 0:3, ::-1].dimshuffle | |
| address.IPv4Address | |
| td.export_data | |
| server_conn.simulate_ecdh_reply | |
| array_1d.reshape | |
| Partition | |
| p.Create | |
| ThingModerationMixin().send_removal_message | |
| np.arange(2 * 4 * 2).reshape | |
| Iter().slice | |
| td.api.update_schema.assert_called_with | |
| error | |
| cs.backups.create | |
| self.test | |
| p.GetPixel | |
| config.setdefault | |
| b5.mentionOf | |
| sample_without_replacement | |
| self.R.sentMail | |
| ws0.write_merge | |
| options.IntOption | |
| NamedColor | |
| self.gh.pull_request | |
| Employee.objects.annotate(min_salary=Window(expression=Min('salary'), partition_by=F('department'), order_by=[F('salary').asc(), F('name').asc()])).order_by | |
| t.Enum | |
| Book.objects.filter(pk=self.b1.pk).annotate(mean_age=Avg('authors__age')).values_list | |
| User | |
| testdir.run | |
| RI | |
| StrFixedLenField | |
| self.url | |
| MethodTest.Overloaded.__overloads__[str, int, int] | |
| X.dimshuffle | |
| self.str_format.format | |
| po.reshape | |
| Gdk.RGBA | |
| np.array([[2, 2, 1, 1]], dtype=np.float32).reshape | |
| np.array([6, 7, 10, 11], dtype=np.float32).reshape | |
| self.cs.agents.create | |
| RadialGradient | |
| provider | |
| self.channel.exchange_unbind | |
| generate | |
| SaucerGlyph | |
| seldlg.control | |
| x509.DistributionPoint | |
| np.arange(10).reshape | |
| UnsortedDataclass | |
| self._build_url | |
| _app | |
| GLib.Error.new_literal | |
| MafIndex | |
| self.config.enhance | |
| img.Replace | |
| build_source_pattern | |
| conn.start_workflow_execution.when.called_with | |
| att_1.permute | |
| ProcessLogEvent | |
| logger.opt(colors=True).debug | |
| mock_type.assert_called_with | |
| d12 | |
| _cb_quoting | |
| SearchScope.create_path | |
| b2.c.transpose | |
| sc.roots_gegenbauer | |
| s.set_timing | |
| sm.distributions.zipoisson.logpmf | |
| producer.create_topic | |
| gammainc | |
| result[0].reshape | |
| m4.translate | |
| qRgb | |
| MockBP | |
| PolarStereographicAConversion | |
| new_text_cell | |
| pub.set_components | |
| _frange | |
| flow_obj._get_authorize_url | |
| kid_rsa_public_key | |
| mode_rb | |
| domImpl.createDocument | |
| self.config.add_view_deriver | |
| ScopeIds | |
| TemplateSyntaxError | |
| events.MemoryUsageUnderThreshold | |
| cr.set_source_rgb | |
| stats.binom_test | |
| pjoin | |
| ConfigValue | |
| _ErrorInfo | |
| AbiquoNodeDriver | |
| Alias | |
| match_obj.group | |
| tools.replace_in_file | |
| License | |
| Perm(0, 14, 10)(1, 9, 16)(2, 13, 17)(3, 19, 11) | |
| g2.edges.select | |
| g.scale | |
| dns.Record_AFSDB | |
| self.driver.ex_attach_server_to_shared_storage | |
| self.tmpdir.join | |
| hyp1f2 | |
| wrapper.hhn_dynamic_create | |
| util.Regex.matches_kv | |
| mc.convert | |
| mode.replace | |
| implementations.ssl_channel_credentials | |
| ParseError | |
| torch.nn.Conv2d | |
| dns.Record_NAPTR | |
| composer.install | |
| _DBRef | |
| parted.disk_set | |
| cli._handle_debug | |
| self._test_create | |
| client.add_permission_for_apigateway_v2 | |
| client.create_retention_policy.assert_called_once_with | |
| httplib2._wsse_username_token | |
| client_conn.simulate_ecdh_reply | |
| self.mockserver.__exit__ | |
| np.arange(2 * 3 * 5, dtype=np.int64).reshape | |
| Month | |
| np.array([0.1, 0.3, 0.5, 0.7, 0.9], dtype=np.float32).reshape | |
| self.conversion | |
| I2CTimings | |
| RegexpReplace | |
| self.child.send | |
| Hypergeometric | |
| self.w_cm.__exit__ | |
| self.path_info.replace | |
| mock_attr.assert_called_once_with | |
| cephes.pro_ang1 | |
| namedtuple('iostat', 'read_count, write_count, read_bytes, write_bytes, read_time, write_time') | |
| dacl.add_ace | |
| notify2.Notification | |
| LambertCylindricalEqualAreaConversion | |
| diag_accum.record_stream_init | |
| arange(3).reshape | |
| self.protocol.onClose | |
| feature_mul.transpose | |
| np.arange(24, dtype=float).reshape | |
| compute_jac_indices | |
| M_ | |
| G.add_edge | |
| linear_congruence | |
| ARN | |
| cephes.nbdtr | |
| np.arange(20, dtype='f').reshape | |
| self.b.on_chord_part_return | |
| mattrgetter | |
| logger.info | |
| zope.deferredimport.defineFrom | |
| self._nr_instance._nr_wait_function_trace.__exit__ | |
| v1 | |
| gcs.validate_response | |
| config_manager.getoption | |
| np.arange(5 * 5 * 5, dtype=np.complex64).reshape | |
| self.add_style | |
| self.touch | |
| self.client.__exit__ | |
| actions_layout.setContentsMargins | |
| ipython_with_magic.run_cell_magic | |
| y.transpose | |
| View | |
| xrange | |
| address.IPv6Address | |
| redis.zrevrangebylex | |
| robjects.baseenv['seq'] | |
| self.VarArgs.call | |
| layout_info.setContentsMargins | |
| tab2hbox.setContentsMargins | |
| wx.PasswordEntryDialog | |
| self._connectRoute | |
| _BoundedMongoSource | |
| S3FeedStorage | |
| ExGaussian | |
| index._add_wordinfo | |
| IgnoreList().exclude('*.02', '*.03', '04.*', 'bar.txt', '*.05', 'some/directory/*.cfg').global_exclude | |
| self.translations.dngettext | |
| renamed_logging.warn | |
| optuna.distributions.DiscreteUniformDistribution | |
| np.array([[0, 1, 2], [3, 2, 1], [4, 5, 6], [7, 6, 5], [0, 1, 4], [5, 4, 1], [2, 3, 6], [7, 6, 3], [0, 2, 4], [6, 4, 2], [1, 3, 5], [7, 5, 3]]).reshape | |
| RPM | |
| ExGaussianDistribution | |
| CONF.get | |
| auth._hash_pbkdf2_secret | |
| self.check_boolean | |
| progress.text | |
| CoreFoundation.CFDateFormatterCreateDateFormatFromTemplate | |
| _BaseHeaderFooter | |
| _jedi_path.joinpath | |
| api.update_vlan | |
| win_pdh.get_counter | |
| soup.a.insert_before | |
| out2.transpose | |
| special.pro_cv_seq | |
| Sub1Block | |
| grid.setContentsMargins | |
| u'# {:20} {:<15} {:<10} {:<15s}'.format | |
| ctestdir.runpytest | |
| osgeo.join | |
| self.registry.lookup | |
| totp.verify | |
| tools.params | |
| perm_mask.permute | |
| PackageFinder.create_path | |
| runs.set_run | |
| u.xpath | |
| launch_mcd_on_dataset | |
| tsa.exc.NoReferencedColumnError | |
| client.app_profile_path | |
| a.rol | |
| datetime.time | |
| np.arange(7 * 13 * 8, dtype=np.int16).reshape | |
| Cauchy | |
| images | |
| fake_basic_qos.assert_called_once_with | |
| np.arange(30 * 4 * 5).reshape | |
| self.checked_add | |
| sc.roots_sh_jacobi | |
| f.createVariable | |
| datetimex | |
| pattern.add_color_stop_rgba | |
| mock__mkfs.assert_called_with | |
| Quartz.CGAffineTransformMake | |
| 'This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.'.format | |
| deploy_sys.nexus_stage_repo_close | |
| api_general_client.getTestCasesForTestSuite | |
| super | |
| self._hyper3.SetUnderlines | |
| syntax_layout.setContentsMargins | |
| dta['N2'].values.reshape(n + 1, m, m, order='F').transpose | |
| self.seq | |
| _ContentType | |
| self.client.test_and_set | |
| self._match_or_else | |
| endpoint.replace | |
| auth.validate_authentication | |
| redis.bitcount | |
| config.add | |
| unpack_from | |
| self.api.appendStep | |
| np.arange(60, dtype=dtype).reshape | |
| truncate_name | |
| crit.UCB | |
| UnaddableError | |
| line.startswith | |
| _raise | |
| tab_layout.setContentsMargins | |
| RequirementsFileParseError.create_path | |
| r.rpush | |
| self.environment.runner.stats.log_request | |
| config.get_value | |
| m | |
| fn.mkBrush | |
| Author.objects.values | |
| helper.render_to_response | |
| deprecate_with_version | |
| arange(24, dtype='<i4').reshape | |
| DistributionData | |
| http_exceptions.LineTooLong | |
| D2xx.create_error | |
| self.load_backend | |
| XNBytesField | |
| td.api.tail.assert_called_with | |
| repository.create_release | |
| util.min_libcurl | |
| IntFormat | |
| a.set_ra | |
| AccessControlChangeCounters | |
| img.unsharp_mask | |
| genVersion | |
| good | |
| m.popup | |
| res.smoothed_state_autocovariance(2, start=8, end=9).transpose | |
| mock_upload_tarball_by_url.assert_called_with | |
| cephes.chndtrinc | |
| special.sph_harm | |
| self.option_file_parser.get_groups | |
| CoreFoundation.CFPreferencesSetAppValue | |
| test_time | |
| distro.LinuxDistribution | |
| mock_attr.abc | |
| bf.set('u8', 8, 254).overflow('fail').incrby | |
| Slotsdataclass | |
| self._create_test_file | |
| XmlDynamicListParam | |
| aws_encryption_sdk.internal.formatting.encryption_context.read_string | |
| timescale.tai | |
| res.smoothed_state_autocovariance(-2, start=8, end=9).transpose | |
| self.cs.services.force_down | |
| Result | |
| HTTPException | |
| a | |
| real_datetime_class | |
| host.find | |
| s.interface_attach | |
| sheet.insert_bitmap | |
| keyring.set_password | |
| cephes.nbdtrc | |
| QRectF | |
| boto.config.getbool | |
| c.addPyMethod | |
| special.betaincinv | |
| stats.hypergeom.cdf | |
| nxm_header_w | |
| Perm(0, 1, 2)(3, 5, 7) | |
| graph.msg | |
| self.format_row | |
| xsd.dateTime | |
| DatetimeAllLeap | |
| td.swap_table | |
| line.replace('[', '|', 1).replace | |
| '{} {}'.format | |
| idx._maybe_cast_slice_bound | |
| '{:^15}{:^15}{:^15}{:^15}{:^15}'.format | |
| ImageCms.buildTransform | |
| choice | |
| self.get_process_exited_event | |
| oscillatory_network_2.simulate | |
| mock.module | |
| sm.distributions.zigenpoisson.logpmf | |
| calculate_dwell_time | |
| awsclient.deploy_rest_api | |
| img.statistic | |
| a.transpose | |
| transfer.download_file | |
| PlanimeterTest.polygon.TestEdge | |
| cephes.nrdtrimn | |
| extension.create_hook_include_file | |
| self._substitute | |
| '{}/{}'.format(self.__url_for_job(job_id), log).replace | |
| ui.config | |
| self.driver._set_project_metadata | |
| redis_sentinel.set | |
| self._test_exam_type | |
| testvars.delete_period_proto.format | |
| _TLSRandomBytesField | |
| np.array([1.0, 2.0]).reshape | |
| deprecated_args | |
| Derived | |
| parent_body.replace | |
| CipherSuite | |
| imp.createDocumentType | |
| client.DeviceFlowInfo | |
| static.SingleRangeStaticProducer | |
| _ex | |
| j | |
| umount_mock.assert_called_once_with | |
| qsturng | |
| delete_count_pattern.format | |
| iptables.execute_iptables_cmd | |
| np.random.RandomState(0).randn | |
| option | |
| ungettext | |
| wx.Colour | |
| ExecFailed | |
| nfa1.add_transition | |
| result.add_reason | |
| self.db_op.switch_update_record_with_switch | |
| prawcore.TrustedAuthenticator | |
| endpoints.TCP6ClientEndpoint | |
| IDNA2008Codec | |
| self.api.callServerWithPosArgs | |
| is_file_url.create_path | |
| td.update_expire | |
| r.substr | |
| cmdoptions.create_path | |
| self._test_filter | |
| pandoc.pandoc | |
| SystemConfiguration.SCNetworkConnectionCopyUserPreferences | |
| g.add | |
| rsa_public_key | |
| testenv.run | |
| w2.transpose | |
| str_tools.size_label | |
| RelayCell | |
| self.wait_thread.__exit__ | |
| pywintypes.error | |
| pipe.set('a', 'a1').get('a').zadd('z', {'z1': 1}).zadd('z', {'z2': 4}).zincrby | |
| RectangleInfo | |
| params['color'].replace | |
| SceneKit.SCNVector4Make | |
| self.methodsTable.performSelectorOnMainThread_withObject_waitUntilDone_ | |
| build_filter | |
| Permutation(0, 1, 5, 2) | |
| wx.EmptyBitmap | |
| paginate | |
| QColor.fromCmykF | |
| TextureAtlas | |
| m.g | |
| configuration.get_config().getboolean | |
| array2.sort | |
| InfluxDBClient | |
| self.var_map[self.array].get_type().replace | |
| e.equals | |
| SingularityFunction | |
| self.send_gpmdp_msg | |
| cuda.cupy.arange(2 * 3 * 4 * 3, dtype=self.dtype).reshape | |
| self.channel.queue_unbind | |
| UVarIntField | |
| scipy.stats.nbinom.logpmf | |
| Book.objects.filter(pk=self.b1.pk).annotate(mean_age=Avg('authors__age')).values | |
| pgdb.Time | |
| CoreFoundation.CFCopyLocalizedStringFromTable | |
| np.arange(6 * 3 * 2 * 2).reshape | |
| bf.set | |
| cephes.obl_rad1_cv | |
| num2date | |
| hyper2.SetColours | |
| self._check_explorer_url | |
| self.ui.config | |
| re.match('(\\d+)\\.(\\d+)\\.(\\d+)', server_version).group | |
| wireprotoserver.sshv1protocolhandler | |
| lmfit.Parameter | |
| obj.method_stararg | |
| erepo_dir.dvc_gen | |
| diag | |
| ReqRepRequest | |
| NSLocalizedStringFromTable | |
| t.color_rgb | |
| self.capture | |
| lsmrtest | |
| array4.argsort | |
| w.transpose | |
| smart_datetime | |
| c.stub_request | |
| vi_pos_end_long | |
| cftime.DatetimeAllLeap | |
| self._az_config.get | |
| self.partition_utils.mkfs | |
| Xor | |
| matching_vector_max.permute | |
| period_range | |
| Bookmark.objects.prefetch_related | |
| conv_utils.conv_input_length | |
| FileChunk | |
| IPv4Address | |
| n.dimshuffle | |
| layout.scale | |
| requierd_mutually_exclude_options | |
| self.cfg.set | |
| w.wcs_world2pix | |
| SubSubSlotted | |
| salt.utils.stringutils.check_include_exclude | |
| ParseException | |
| TaskState.objects.reviewable_by(request.user).select_related | |
| self.vboxlayout2.setContentsMargins | |
| ConfigFileFinder | |
| targ_pts.permute | |
| RGBColor | |
| run_benchmark | |
| datetime.add | |
| theano.compile.get_default_mode().excluding | |
| self.resolve_class | |
| arange(12.0).reshape | |
| is_palindromic | |
| namedtuple('iostat', 'bytes_sent, bytes_recv, packets_sent, packets_recv, errin errout dropin dropout') | |
| Quartz.CIColor.colorWithRed_green_blue_alpha_ | |
| libcloud_loadbalancer.balancer_attach_member | |
| _helpers._add_query_parameter | |
| URIReference | |
| ImpliedDoLoop | |
| Erlang | |
| np.arange | |
| p1.subscribe | |
| self.ec2.copy_snapshot | |
| self.check_filename | |
| self._parse | |
| _Authorization | |
| _c_PruneStats | |
| cherrypy.lib.httputil.Host | |
| jid.prep | |
| self.GLib.check_version | |
| XBitField | |
| LinearGradient | |
| funcs.signal_to_noise_oir_ccd | |
| Charset | |
| child_trace_1.__exit__ | |
| raw['x'].transpose | |
| np.arange(27.0).reshape | |
| agent._create_req.assert_called_once_with | |
| provider.Provider | |
| self.transaction.__exit__ | |
| conn.create_customer_gateway | |
| keychain.default_keychain | |
| trans.transform | |
| self.ec2.copy_image | |
| s.fill_region | |
| jedi.set_debug_function | |
| Group | |
| IRCAccount | |
| s[0].permute | |
| require | |
| assertExpectedParse | |
| mod.replace | |
| self.datecls | |
| apple.tags.add | |
| PDFSurface | |
| F_c.transpose | |
| arr.reshape | |
| W.transpose | |
| db.flags | |
| self.translations.dunpgettext | |
| up_y.transpose | |
| sheet.get_array | |
| self.async_exit_stack.__aexit__ | |
| news_results.gain.transpose | |
| h_group_layout.setContentsMargins | |
| self._test_body | |
| github3.markdown | |
| cephes.btdtria | |
| img.border | |
| _IfModifiedSince | |
| self.pdf.set_font | |
| geometry.box | |
| hp.qnormal | |
| stats.ncf.var | |
| joinedload_all | |
| api_helper_class | |
| graph.coordinates | |
| elasticsearch.document_delete | |
| AccessEntry | |
| _jpype._JProxy | |
| sc.convert_temperature | |
| ClientSecretCredential | |
| expected.add_edge | |
| html.replace | |
| client.backup_path | |
| Color | |
| self.translations.ungettext | |
| results | |
| register_prime_curve | |
| self._ManifestUpload | |
| Gaussian2DKernel | |
| from_spherical | |
| cache_property | |
| d12v | |
| ENUM | |
| m1.group | |
| '{0:9} {1:40}{2:18}{3}'.format | |
| BooleanControl | |
| klass.field_path | |
| FiniteSet | |
| Transform | |
| view2.get_list | |
| self.basic_m.set_block | |
| _NewConnectionHelper | |
| E_nl_dirac | |
| self.cs.agents.update | |
| ConnectionKey | |
| self.__test_instance.forecast_at_place | |
| distribution.create_linear | |
| f2 | |
| SeparableConv2d | |
| repo.get_store().should_receive('put').with_args | |
| s.write | |
| NormalIntegerHyperparameter | |
| make_safe_uri_test | |
| table.setName | |
| db.query | |
| c.addCppMethod | |
| Perm(0, 6, 8)(1, 7, 2)(3, 5, 11) | |
| mod.API_VERSION_OPTION.replace | |
| stem.util.enum.Enum | |
| sender.build_message | |
| _out_seq.dimshuffle | |
| cc.connectUNIX | |
| mo.group | |
| self.convert_paths | |
| Line | |
| np.arange(np.prod([3, 1, 5, 6])).reshape | |
| style_guide.Violation | |
| Graph.GRG | |
| t.bold | |
| gcs_json_api.GcsJsonApi | |
| AppKit.NSRunAlertPanel | |
| _make_string_state | |
| self.channel._queue_bind | |
| out.write_short | |
| config.get | |
| btrfs.add | |
| cr.entry_point | |
| error_pytester.runpytest | |
| f.add_transition_any | |
| c.add | |
| r.setrange | |
| verifiers.FileChecksumMatcher | |
| ServerOptions | |
| Box | |
| namedtuple('swap', 'total used free percent sin sout') | |
| nx.relaxed_caveman_graph | |
| boto.config.getint | |
| t._saveV2Tag | |
| digits.add_transition | |
| conn.describe_workflow_type.when.called_with | |
| FlavorsTest._create_body | |
| gy.rotate | |
| client.stats | |
| player.wait_for_all_events | |
| repos.config.set | |
| self._run_test | |
| Permutation(0, 2, 4, 6) | |
| v.index | |
| self.mock_client.service_principal.assert_called_once_with | |
| args[0].replace | |
| s.query | |
| input_generator.increasing | |
| functions.Translate | |
| urllib.quote(x.encode('utf-8')).replace | |
| quad_factory | |
| self.set_autoscaling_spot | |
| ltime2 | |
| self.session.get_available_regions | |
| np.arange(48, dtype=np.complex64).reshape | |
| QtCore.QRect | |
| np.expand_dims(np.expand_dims(W_Y, axis=3), axis=4).transpose | |
| self.pamd_line.matches | |
| line.is_next_mapping | |
| rel_pos_embeddings.view(rel_pos_embeddings.shape[:2] + (self.num_buckets, self.num_attn_heads)).permute | |
| self.c._basic_publish | |
| TooLong | |
| conf.set | |
| namedtuple('usage', 'total used free percent') | |
| file.createVariable | |
| temp_dir.join | |
| Tiff | |
| jutil.get_static_field | |
| genpy.message.check_type | |
| cephes.fdtri | |
| array(hsv).reshape | |
| conn2.execute | |
| func.some_comparison | |
| L.Convolution2D | |
| cephes.nbdtri | |
| ActionInfo | |
| input.dimshuffle | |
| ext.frame_inbound_header | |
| DistributionNotFound.create_path | |
| self.partition_utils.wait_for_dev | |
| MethodTest.DefaultParams | |
| AudioFormat | |
| self.makeSubtable | |
| Target.construct_id_from_path | |
| jtheta | |
| FileBlock | |
| np.arange(7 * 6 * 8).reshape | |
| bf.set('u8', 8, 255).incrby('u8', 8, 1).set | |
| vim.Vim | |
| m.group | |
| app.Cron | |
| new_es.normalize_entity | |
| KeysEqual | |
| RosdepDefinition | |
| transport.SSHCiphers | |
| Epoch.is_julian | |
| self.clusters_mock.resize.assert_called_with | |
| label.setContentsMargins | |
| Datetime | |
| fig_ref.text | |
| '{0:40} {1:40s} {2:40s} {3}'.format | |
| ip.complete | |
| e.elementary_row_op | |
| r.hincrby | |
| win32structures.KBDLLHOOKSTRUCT | |
| mock.call().__exit__ | |
| a.count | |
| mathfilters.handle_float_decimal_combinations | |
| Account3 | |
| dialect.is_disconnect | |
| update | |
| self.gh.issue.assert_called_with | |
| a.splice | |
| console.setGeometry | |
| cancel.text | |
| out2int.transpose | |
| orig_datetime | |
| myTeamsPotentialAction2.addAction | |
| declarations.Maybe | |
| self.set_operation_return_value | |
| CounterName | |
| datetime.fromisocalendar | |
| Basic | |
| tag.lyrics.set | |
| f.join | |
| dut.api('acl').update_entry | |
| self.MakeBitmap2 | |
| self.sb_hor.SetScrollbar | |
| keystone.endpoint_create | |
| cone | |
| np.random.RandomState(42).randn | |
| Metric | |
| bf.set('u8', 8, 255).incrby('u8', 8, 1).set('u8', 8, 255).incrby('u8', 8, 1, 'FAIL').incrby | |
| Submission.objects.filter(created_at__range=(min_datetime, max_datetime), student_item__item_type='openassessment', answer__contains='files_sizes":[').order_by('student_item__course_id', 'student_item__student_id').select_related('student_item').values_list | |
| SvgGradientCoord | |
| module.double_add | |
| self._simple_test | |
| QRect | |
| self._test_build_create_key_pair_batch_item | |
| np.ma.arange(24).reshape | |
| ObjType | |
| rh_ip.build_interface | |
| b.add_edge | |
| JzKetCoupled | |
| h5file.createGroup | |
| Binomial | |
| RowLookup | |
| tmp_dir.dvc_gen | |
| self.templateSimulateStaticOutputDynamic | |
| CandidateEvaluator.create_path | |
| pydt.date | |
| self.config_loader.get | |
| query.where | |
| self.authServer.tryAuth | |
| self.service_connection.restore_dbinstance_from_point_in_time | |
| stor.VDisk.bld | |
| self.privkey.export_private_key | |
| self.pdc.TranslateId | |
| Config.getdefaultint | |
| index_group.create_path | |
| series_data.add_data_point | |
| DatabricksConfig | |
| a.defnode | |
| FunctionInfo | |
| configparser.InterpolationMissingOptionError | |
| r.psetex | |
| redis.zrangebylex | |
| op.create_index | |
| np.arange(4 * 4 * 6).reshape | |
| besselyzero | |
| buc.nodejs_compile | |
| s.read | |
| XmlParam | |
| cephes.pro_rad2 | |
| given_adapter.init_poolmanager | |
| mat['dat'][i][j].reshape | |
| util.parent_spec | |
| OpWiseCLinker().accept(g).make_function() | |
| JWSEHeaderParameter | |
| Str | |
| CStructOrUnionType | |
| hyp2f0 | |
| mkd | |
| MyFormat | |
| response.__exit__.assert_called_once_with | |
| libcloud_compute.attach_volume | |
| img.level | |
| Permutation(5, 7, size=8) | |
| cfg.set_section_option | |
| redis.zlexcount | |
| np.einsum | |
| format_number | |
| cephes.chndtr | |
| rgb | |
| IcoFormat | |
| self.translations.lnpgettext | |
| np.arange(18).reshape | |
| expected.replace | |
| url_to_path.create_path | |
| changed_dirname.replace | |
| dialect._get_column_info | |
| PerformLinker().accept(g).make_function() | |
| self.driver.create_volume | |
| Union | |
| colors.CMYKColor | |
| ucd.parse_ucd | |
| filemod.stats | |
| config.getfloat | |
| dns.rdata.from_text | |
| self.driver.ex_authorize_security_group | |
| tr.setTranslate | |
| Perm(0, 8, 15)(1, 12, 16) | |
| Record | |
| np.ndindex | |
| SCRAMHashInfo | |
| true_false_perms | |
| api_general_client.createBuild | |
| kolmogn | |
| AClass | |
| write_mock.assert_called_once_with | |
| Model | |
| np.repeat(np.float32(4.0), 24).reshape | |
| self.cs.migrations.list | |
| np.arange(matrix_ct * 4 * 5, dtype=np.float32).reshape | |
| mathieuc | |
| all_people.filter(age__gte=10).defer | |
| pole.set_color | |
| d11v | |
| namedtuple('Reponse', ['content', 'response', 'reason', 'status_code']) | |
| Foundation.NSDictionary.dictionaryWithObjectsAndKeys_ | |
| bf.incrby('u8', 8, 254).incrby | |
| self._session.get_url | |
| ajoin | |
| cephes.besselpoly | |
| String | |
| np.arange(27).reshape | |
| pluralize | |
| logger.opt(colors=True).info | |
| sasl_mechanisms.DigestMD5 | |
| get_levels_mock.assert_called_once_with | |
| atom.Content | |
| self.default_store.store | |
| BackoffSettings | |
| basesupport.AbstractAccount | |
| synthetic_pipeline.SyntheticSDFStepRestrictionProvider | |
| app.add_config_value | |
| integerFactory | |
| File | |
| bch.HSL | |
| mock_update.assert_called_once_with | |
| self.set_color | |
| server_str.replace | |
| _merge_ssl_params | |
| ' {:15} {:15} {2}'.format | |
| f3 | |
| self.hboxlayout.setContentsMargins | |
| o.pop | |
| ui.configbytes | |
| self.squarePath.addRect | |
| req.path.replace | |
| Rectangle | |
| decode | |
| img.chop | |
| np.arange(3 * 7 * 5).reshape | |
| BoundedPareto | |
| contains_any | |
| np.random.RandomState(1234).randint | |
| Quartz.CIColor.colorWithRed_green_blue_ | |
| get_completion_script | |
| Node | |
| OneOf | |
| self.pdf.set_text_color | |
| DocumentPart | |
| Perm(0, 16, 13)(1, 17, 8)(2, 11, 12)(3, 6, 18) | |
| Perm(0, 5, 1)(2, 4, 6) | |
| racah | |
| self.sb_vert.SetScrollbar | |
| self.rg.beta | |
| r.zadd | |
| routing_range._Range | |
| libcloud_compute.copy_image | |
| deprecated_attr | |
| client.table_path | |
| Operation | |
| np.mgrid[:100, :100].transpose | |
| CliParser | |
| np.geomspace | |
| unpack2 | |
| MergedCell | |
| mgr.get_tile | |
| Gompertz | |
| OldVectors.dense | |
| assert_index | |
| generate_property_deprecation_message | |
| Cocoa.NSAlert.alertWithMessageText_defaultButton_alternateButton_otherButton_informativeTextWithFormat_ | |
| set_new_country | |
| smart_open.open | |
| HSPFragment | |
| nutation_obliquity | |
| self.fs.__exit__ | |
| operator.methodcaller | |
| GalaxyAPI | |
| match | |
| Perm(0, 11, 15)(1, 17, 14)(2, 18, 9) | |
| self.session.xenapi.VM.start.assert_called_with | |
| header_value.replace | |
| result.assert_outcomes | |
| SplatGlyph | |
| original_datetime | |
| mode.including | |
| _read_table | |
| x.request | |
| sg.remove_rule | |
| g.wasAssociatedWith | |
| p.add | |
| get_human | |
| self.stream.current.test_any | |
| '{0:^4} {1:>16} {2:>8} {3:>8} {4:>12}'.format | |
| calc_gdal_version_num | |
| jutil.static_call | |
| QGraphicsEllipseItem | |
| np.arange(30107).reshape | |
| Importation | |
| a.date_type | |
| bq_verifier.BigqueryMatcher | |
| callback.assert_called_once_with | |
| drac.change_password | |
| IntTypeSpec | |
| make_termlist | |
| self._process_range | |
| uni.combine | |
| pkg_resource.version_compare | |
| Jpeg | |
| imageio.plugins.example.DummyFormat | |
| span.__exit__ | |
| dill.loads(dumped_func_d) | |
| action | |
| CoreFoundation.CFDataCreate | |
| self.install_filter | |
| table.add_row | |
| Perm(0, 11, 15)(1, 17, 14)(2, 18, 9)(3, 12, 13) | |
| QtGui.QColor | |
| TypeAnnotation | |
| self.nbconvert_api.from_file | |
| self.app.conf.get_by_parts | |
| AppKit.NSColor.colorWithCalibratedRed_green_blue_alpha_ | |
| glClearColor | |
| env.pop | |
| get_requirement_tracker.create_path | |
| fn.mkPen | |
| dist.pdf | |
| np.arange(1).reshape | |
| tfrecords_reader._AbsoluteInstruction | |
| self.bw.query | |
| Child | |
| mock_add.assert_called_once_with | |
| self.setPosition | |
| Parameter | |
| p.subscribe | |
| qs1.intersection(qs1).values_list | |
| context.rectangle | |
| IgnoreList().recursive_exclude | |
| FeatureDeprecated | |
| mock_import_vhds.assert_called_with | |
| bbox_from_ext | |
| response.set_cookie | |
| port.convert | |
| self._test | |
| SingleValueConstraint | |
| async_poller | |
| has_network_access | |
| date_type | |
| mi.nth_product | |
| psycopg2.Timestamp | |
| wcs.world_to_array_index_values | |
| self.mktemp | |
| ExponentialPowerDistribution | |
| DemoNumber | |
| r.group | |
| windows.Window | |
| libcloud_compute.destroy_volume_snapshot | |
| values.str.find | |
| np.repeat(np.int32(2), 24).reshape | |
| randint | |
| session.KmipSession | |
| self.assert_message_logged | |
| ndmsg.sql_schema().unique_index | |
| Perm(0, 3, 4)(1, 8, 10)(2, 9, 5) | |
| AppKit.NSMakeRect | |
| stor.LUEnt.bld | |
| m1.add_seasonality | |
| deltafrag | |
| Foo | |
| array.y.layout.argsort | |
| self.rg.laplace | |
| result.assert_called_once_with | |
| img.range_threshold | |
| options | |
| self.cli.create_user | |
| wcs.pixel_to_world | |
| error.replace | |
| XYZColor | |
| translate | |
| bad | |
| pm.Uniform | |
| arange(8).reshape | |
| stats.hypergeom.pmf | |
| self.assertHeader | |
| d.Time | |
| cmd.replace | |
| GdkPixbuf.Pixbuf.new_from_data | |
| menu1.Append | |
| hdfs.chown | |
| cs.group_types.create | |
| bic | |
| dta['N1'].values.reshape(n + 1, m, m, order='F').transpose | |
| redis.hincrby | |
| t.suggest_int | |
| self._blake2s | |
| MLEModel.from_formula | |
| b.trace | |
| _init_lookup_cell | |
| a['a'].transpose | |
| addStar | |
| webcolors.HTML5SimpleColor | |
| experiment.append_tag | |
| Perm(0, 14, 10)(1, 9, 16)(2, 13, 17) | |
| pyrect.Rect | |
| Perm(11) | |
| w.cell | |
| CoreFoundation.CFURLCreateWithString | |
| u.configbytes | |
| helpers.create_member_configuration | |
| ArrayType(range(24)).reshape | |
| feed.add_set_cell | |
| Perm(0, 7, 9) | |
| CompilerId | |
| SolidPattern | |
| self.table_index.setContentsMargins | |
| wl.setContentsMargins | |
| PyFunctionDef | |
| dif.replace | |
| netscaler.servicegroup_server_enable | |
| self.gridlayout.setContentsMargins | |
| s.startswith | |
| self.add | |
| model.SecurityGroup | |
| Foundation.NSSet.alloc().initWithObjects_ | |
| hp.uniform | |
| Permutation(1, 3, size=8) | |
| make_method | |
| p5.setLabel | |
| surf.subsurface | |
| L | |
| _ARCH | |
| drop | |
| self._expand | |
| create_mock_raw_stream | |
| comparer.distance | |
| shapes.Wedge | |
| TPickle3 | |
| self._testRegistryPolicy | |
| pkgconfig | |
| pg.QtGui.QGraphicsRectItem | |
| template_format.format | |
| pcss | |
| QtGui.QVector3D | |
| pm.gp.cov.Polynomial | |
| binom.pmf | |
| VolumeSpec | |
| option.replace | |
| MultiHeader | |
| pg.mixer.pre_init | |
| Version | |
| self.dlg.move_window | |
| test_utils.FakeOpcode | |
| df.expect_column_values_to_be_between | |
| Permutation(4) | |
| inst.Overloaded[str, bool, int] | |
| self.VarArgs.callString0 | |
| connection.begin | |
| win32functions.CreateDC | |
| ThingWithInheritedSlots | |
| combined | |
| _field_accessor | |
| filters.KillFilter | |
| register | |
| np.arange(3 * 3, dtype='u8').reshape | |
| util.Regex.find_kv | |
| redis.zrangebyscore | |
| input_blob.transpose | |
| StructType | |
| pytest.mark.skip_if_binaries_missing | |
| self.call_simple_getter | |
| td.api.list_jobs.assert_called_with | |
| floatFactory | |
| protocol.PartitionOffsetCommitRequest | |
| foo.method1 | |
| ax[2].plot | |
| dns.Record_MINFO | |
| ItalianRestaurant.objects.values | |
| c.update | |
| mount.fstab_present | |
| t.module.link_detail | |
| cheb1ord | |
| self._parser.addini | |
| root.joinpath | |
| shapes.Ellipse | |
| std.dimshuffle | |
| fullname.replace('.', '/').replace | |
| Perm(0, 8, 10)(1, 7, 6) | |
| job.hour.on | |
| win32api.RGB | |
| OneCall | |
| super(OptionSet, self).__init__ | |
| WheelBuilder.create_path | |
| collection.where | |
| conn.deprecate_activity_type | |
| DropboxOAuth2Flow | |
| '{0} {1} {a}'.format | |
| pytd_utils.DummyMethod | |
| Perm(0, 16, 13) | |
| Token | |
| result | |
| SheetReport.REPORT_HEADING.replace | |
| mi.grouper | |
| table._set_windowed | |
| matcher | |
| Gtk.TargetEntry.new | |
| self._mock_event | |
| lib.bar | |
| glusterfs.create_volume | |
| nxm_header | |
| stats3.log_request | |
| CoreFoundation.CFStringCreateWithFormat | |
| etcd.replace | |
| self.init | |
| o.input_output_inputAndOutput_ | |
| dot_rot_grad_Ynm | |
| IOError | |
| hp_loguniform | |
| BaseEnum | |
| mode._optimizer.including | |
| MatrixSymbol | |
| check_failure | |
| task.__exit__ | |
| IP4Range | |
| message.get_unrecognized_field_info | |
| Perm(0, 6, 17, 19, 9)(1, 11, 18, 13, 4) | |
| CFNetwork.CFURLCreateWithString | |
| Backend().write_entry | |
| Permutation(3) | |
| tc.SetTime | |
| _foo2 | |
| self.builder_for_features | |
| client.Client | |
| plt.subplots | |
| kafka.admin.NewTopic | |
| plac.Annotation | |
| commands_dict.create_path | |
| prompt.call | |
| frange | |
| _add_defaults | |
| J.JClassWrapper('org.cellprofiler.javabridge.test.RealRect') | |
| numpy.random.rand | |
| whichusers.radiogroup | |
| layout_edit.setContentsMargins | |
| NR | |
| NumericRange | |
| assert_readline | |
| CoreFoundation.CFStringFind | |
| self.window.__exit__ | |
| self.volume_attribute.endElement | |
| self._run_os | |
| cftime.DatetimeProlepticGregorian | |
| javabridge.static_call | |
| Perm(0, 5, 7) | |
| protocol.basic_error | |
| mock_vios | |
| constraint.PermittedAlphabetConstraint | |
| script_app_with_password().auth.implicit | |
| self.MakeBitmap | |
| meta.setPixelsBigEndian | |
| repository.create_file | |
| _filters._check_mode | |
| r.setex | |
| Triangular | |
| github.get_comment | |
| ffi.offsetof | |
| DSTAwareTimezone | |
| ScalarQueryParameter | |
| bdate_range | |
| m6.rotate | |
| api_client.addTestCaseToTestPlan | |
| gluLookAt | |
| api.GalaxyAPI | |
| a.block_const | |
| ungettext_lazy | |
| marcumq | |
| self.connection.request | |
| p.prepend | |
| wcs.array_index_to_world | |
| self.make_rigged_file | |
| real_datetime | |
| res.smoothed_state_autocovariance(3).transpose | |
| to_jd | |
| asynctest.call | |
| tensor.reshape((config.hidden_size, config.num_attention_heads, -1)).transpose | |
| http.query | |
| np.arange(1000, dtype='i4').reshape | |
| model.objects.values_list | |
| self.table.set_cell_by_ids | |
| deprecate_kwarg | |
| lambdify((x, y, z), Min(x, y, z)) | |
| mask.add_color_stop_rgba | |
| dsa.DSAParameterNumbers | |
| myTeamsPotentialAction1.addInput | |
| out[1].reshape | |
| dnsutil.hosts_append | |
| compute_density | |
| _swf.SetBackgroundTag | |
| psw.ColumnUnit | |
| excerpt | |
| _parse_key_block | |
| cmd.write_file.assert_called_once_with | |
| w.setGeometry | |
| self.channel._create_broadcast_cursor | |
| b'Test: <"&"> '.replace | |
| PBKDF2 | |
| np.linspace(-10, 10, 16).reshape | |
| create_pex_venv | |
| self.response_trace.__exit__ | |
| abc_polling.initialize | |
| redis.geoadd | |
| self._send | |
| _get_version_from_file | |
| self.diff.d_lon.reshape | |
| cls.objects.filter(path__startswith=parent_path, depth=depth).values | |
| df.expect_column_mean_to_be_between | |
| sheet.write | |
| lambdify((x, y, z), Max(x, y, z)) | |
| self._perform_cull_test | |
| BuiltinFunction | |
| CoreFoundation.CFStringCreateArrayBySeparatingStrings | |
| PrimaryKeyConstraint.argument_for | |
| Message | |
| chakraCore.DllMain | |
| clayout.setContentsMargins | |
| Sub4Block | |
| Testee | |
| self.split | |
| datatypes.Array | |
| format_reflog_line | |
| CONF.set | |
| search_jar | |
| MPI.DOUBLE.Create_vector | |
| Book.objects.annotate(pub_year=ExtractYear('pubdate')).values('pub_year').annotate(top_rating=Subquery(Book.objects.filter(pubdate__year=OuterRef('pub_year')).order_by('-rating').values('rating')[:1]), total_pages=Sum('pages')).values | |
| client.OAuth2Credentials | |
| self.SetCellValue | |
| duo_client.client.Client | |
| NamedCache.make | |
| swarm.swarm_init | |
| self.host.XenAPI.Session().xenapi.pool.join.assert_called_with | |
| proxy.callRemote | |
| hyperu | |
| array.sort | |
| model._get_prediction_index | |
| self.service_connection.restore_dbinstance_from_dbsnapshot | |
| self.scene.setSceneRect | |
| _model._load_estimator | |
| EnumMember | |
| FixedOffset | |
| mock_configure_scsi_device.assert_called_with | |
| self.udev.set_dynamic_latency | |
| stor.VMediaRepos.bld | |
| structured_lists | |
| mouse.move | |
| Any | |
| unittest.TextTestResult | |
| self.setSpacing | |
| hass.config.path | |
| IgnoreList().exclude('*.02', '*.03', '04.*', 'bar.txt', '*.05', 'some/directory/*.cfg').global_exclude('*.10', '*.11', '*.12').prune('30').recursive_exclude('40', '*.41').recursive_exclude | |
| stats.beta.logpdf | |
| makespec.Path | |
| Package | |
| StrOption | |
| numpy.random.randn | |
| uni.allexcept | |
| cairo.Matrix | |
| timedelta | |
| mock_disassoc.assert_called_once_with | |
| m.dimshuffle | |
| LinkCollector.create_path | |
| urllib.quote(x.encode('utf-8')).replace('%2C', ',', 'g').replace('%3A', ':', 'g').replace('%40', '@', 'g').replace | |
| img.ConvertToGreyscale | |
| np.array([[0, 0.0, 0.0, 1.0 / 3, 1.0 / 3]], dtype=np.float32).reshape | |
| npgettext_lazy | |
| environ.setval | |
| self._write_tfrecord | |
| cairo.ImageSurface | |
| pbkdf2.create_pbkdf2_hash | |
| builder.add_where_nonzero | |
| Parent2.objects.select_related('child1', 'child1__child4').only | |
| self.obj.emit | |
| db.hset | |
| SpatialCrossMapLRN | |
| dns.rdataset.from_text | |
| hp.Int | |
| np.linspace(-1, 2, num=8 * 8 * 8).reshape | |
| stats.gengamma.pdf | |
| mock_prepare_staging_area.assert_called_with | |
| _make_ref_string | |
| cls.tables | |
| self.make_interactive_app | |
| btn_layout.setContentsMargins | |
| Beta | |
| query_queue[i].put | |
| self.obj.callVarArgs | |
| Foundation.NSLog | |
| Affine | |
| mibBuilder.importSymbols | |
| test_dataframe.expect_column_value_lengths_to_be_between | |
| SceneKit.SCNVector3Make | |
| m2.group | |
| requests.LeaseRequest | |
| self.rtc.BeginSymbolBullet | |
| outer_dot_inputs[0].dimshuffle | |
| r.hsetnx | |
| compare | |
| self.version.at_least | |
| GLib.Regex.new | |
| DateTime | |
| ser._convert | |
| LogNormal | |
| _NamespacePath | |
| smprop.proportions_ztost | |
| updateresult | |
| operation_on_scope | |
| nf | |
| client.set | |
| regex.subf | |
| prop.replace | |
| view3.get_list | |
| gdata.gauth._join_token_parts | |
| decipher_bifid | |
| ctx.set_transaction_constraint | |
| self._drop_remaining_rules | |
| self.nonce.use | |
| self.h5file.get_node | |
| i.forward_search | |
| bitstring.pack | |
| acal.SetDate | |
| locales.loadLocale | |
| Quartz.CGGetDisplaysWithOpenGLDisplayMask | |
| klass.addCppMethod | |
| FakeCredentials | |
| resource.replace | |
| etl.fromhdf5 | |
| self.gridLayout_5.setContentsMargins | |
| decorated_sample | |
| xAxis.setPosition | |
| repo.scm.repo.git.checkout | |
| tt.alloc | |
| Sentinel | |
| pipe.execute_command | |
| javabridge.set_static_field | |
| config.getbool | |
| west_1_conn.create_dbinstance | |
| boto.config.set | |
| fxrange | |
| asa | |
| pretty_format_tree_entry | |
| _kernel32.CreateWaitableTimerA | |
| equal | |
| banded | |
| inuse.control | |
| make_abstract_dist.create_path | |
| plt.subplot | |
| x_crop.transpose(2, 0, 1).reshape | |
| canv.drawString | |
| np.arange(2 * 128 * 128, dtype='int64').reshape | |
| qs.select_related | |
| Perm(0, 9, 6)(1, 3, 11)(2, 8, 7) | |
| cmd_output | |
| hp.loguniform | |
| Quartz.CATransform3DMakeRotation | |
| get_command_environment | |
| sc.roots_genlaguerre | |
| Quartz.CGGetOnlineDisplayList | |
| SlideLayoutPart | |
| input_generator.nonzero_increasing | |
| ap | |
| GradientPalette | |
| atom.mock_service.MockHttpResponse | |
| links.Maxout | |
| _OID | |
| RsvBits | |
| proxy.func | |
| requires_salt_modules | |
| att_stream.permute | |
| ix.add | |
| make_sparse_random_data | |
| hsl_to_rgb | |
| embedding.add_half_edge_cw | |
| ArrowStringDescription | |
| self._bool_option | |
| wireprotoserver.httpv1protocolhandler | |
| stringWidthU | |
| _TableDesc | |
| Foundation.NSCreateZone | |
| Perm(0, 11, 15)(1, 17, 14) | |
| stepwise_pytester.runpytest | |
| dbnd_airflow_path | |
| self._handle.__exit__ | |
| r.replace | |
| self._add_line | |
| vi_pos_word_long | |
| self._fixture | |
| mX.reshape | |
| Perm(0, 11, 8)(1, 7, 3)(4, 6, 12) | |
| self._callFUT | |
| a.choose | |
| signal.butter | |
| a.tags.add | |
| User.objects.create_superuser | |
| _get_closest_ansi_color | |
| Requester | |
| cephes.fdtridfd | |
| test_tuple | |
| sample_fn | |
| s.sendto | |
| configparser.InterpolationError | |
| pipe.immediate_execute_command | |
| ZeroDivisionError | |
| cli._unique_name | |
| x_crop.transpose | |
| self.reddit.auth.implicit | |
| cost.control | |
| self.execute_run | |
| dt_util.dt.time | |
| iso8601.iso8601.FixedOffset | |
| bucket.sign_url | |
| td.import_data | |
| BITBUCKET.create_issue | |
| win_system.join_domain | |
| register_reader | |
| AccessGrant | |
| self.root_layout.setContentsMargins | |
| join_path | |
| machine_a.add_transition | |
| fig.subplots_adjust | |
| self.instance.set_continue | |
| request.setHost | |
| parser.addini | |
| translations.ungettext | |
| roundRectPath.arcTo | |
| cmdmod._render_cmd | |
| self.make_path | |
| r.zrevrangebylex | |
| Trapezoidal | |
| Perm(19) | |
| dns.Record_A6 | |
| cmd.get_models | |
| Extension | |
| img.splice | |
| Perm(0, 4, 5)(1, 3, 10)(2, 9, 6) | |
| six.MovedModule | |
| self.assert_diff | |
| windows.kaiser | |
| ext.replace | |
| ptr['branch'].replace | |
| self.rg.negative_binomial | |
| db.relation | |
| np.array([0, 0.4, 0.8, 1, 1], dtype=np.float32).reshape | |
| Kumaraswamy | |
| self._get_cluster_properties | |
| np.reshape(image, (3, size, size)).transpose | |
| VerticalPerspectiveConversion | |
| self.driver.ex_authorize_security_group_ingress | |
| _combinations | |
| vTime | |
| libc.mount | |
| iso8601.FixedOffset | |
| tf.app.flags.DEFINE_integer | |
| context.__exit__ | |
| self.sc.account.create_user | |
| DNSRRField | |
| self.stubber.add_client_error | |
| lyt.setContentsMargins | |
| is_installable_dir.create_path | |
| salt_call_cli.run | |
| sum_of_powers | |
| arange | |
| render_field | |
| cdate.Date | |
| fakes.FakeVolume | |
| k.replace | |
| self.filter(q).order_by | |
| CircusSocket | |
| qs.filter(id=self.u.id).values | |
| rels.add_rel | |
| DeploymentPreference | |
| c.iterdescendants | |
| d.dimshuffle | |
| XmlAnimatable | |
| fmtstr | |
| u.configint | |
| self.locale._format_relative | |
| ProfileData | |
| v.from_spherical | |
| pytest.mark.usefixtures | |
| benchexec.result.Property | |
| git_ls_files | |
| Eijk | |
| genpy.generator.len_serializer_generator | |
| s.str.rindex | |
| special.hyp1f1 | |
| mock.assert_any_call | |
| r.lrem | |
| fake_pport | |
| lockutils.synchronized | |
| marker.replace | |
| self.cli_ctx.config.set_value | |
| conn.create_dbinstance_read_replica | |
| hs.permute | |
| regex.match('(?:()|(?(1)()|z)){2}(?(2)a|z)', 'a').group | |
| spherharm | |
| r.vector_as | |
| predictions.select | |
| np.arange(48).reshape | |
| assembler2.transform(assembled1).select | |
| Foundation.NSString.alloc().initWithFormat_ | |
| test.method | |
| glBlendColor | |
| repo.ui.configbool | |
| libcloud_compute.create_volume | |
| self.loop.start_tls | |
| gluPerspective | |
| self.circlePath.addEllipse | |
| Locale | |
| np.fromstring(data, dtype=np.ubyte).reshape(texwidth, texwidth, 4).transpose | |
| webcolors.IntegerRGB | |
| am.set_owner_if_different | |
| smp.GofChisquarePower().power | |
| self._graphml.__exit__ | |
| self.tc.Replace | |
| data | |
| WorkflowState.objects.active().filter(Q(page__owner=request.user) | Q(requested_by=request.user)).select_related | |
| wx.NumberEntryDialog | |
| compile | |
| np.repeat(np.complex64(-1.0 + 3j), 24).reshape | |
| variable.replace | |
| __standardize_result | |
| _is_content_range_valid | |
| CoreFoundation.CFStringGetFileSystemRepresentation | |
| __ | |
| self.get_cluster | |
| np.zeros(3 * 3 * 3, dtype='i8').reshape | |
| container.replace | |
| check_ok | |
| data.transpose | |
| FrozenRequirement.create_path | |
| self.block_device_mapping.endElement | |
| deprecated | |
| reducer | |
| store.get_store().should_receive('get').and_return | |
| self.gh.issue | |
| B.reshape | |
| self.gl.glNormal3d | |
| np.arange(6 * 2).reshape | |
| self.assertEqualTextAndNumber | |
| traceback.FrameSummary | |
| c.set_wire_version_range | |
| CMYKColor | |
| Command.create_path | |
| extra_ops.Unique | |
| self.check_response | |
| relocated_module_attribute | |
| resp.mustcontain | |
| mock_remove.assert_called_once_with | |
| _build_wrapped_jce_cmp | |
| self._add_submodule | |
| np.tile(np.arange(12), 5).reshape | |
| self.__test_instance.forecast_at_id | |
| unicode_parm | |
| input_output_inputAndOutput_ | |
| ftputil.FTPHost | |
| DatetimeSubclass | |
| Pareto | |
| self.t0._time.jd1.reshape | |
| cephes.pro_rad2_cv | |
| sm.distributions.zipoisson.cdf | |
| a.slice_by_component | |
| FreeformBuilder | |
| fn.permute | |
| _make_getset_interval | |
| callback1.assert_called_once_with | |
| py_datetime.date | |
| consumer.__exit__ | |
| np.arange(11 * 2).reshape | |
| appdir.runpytest | |
| classObject.Create | |
| data.__exit__ | |
| smtp.ESMTPClient | |
| dt.date | |
| self.grammarbox.tag_remove | |
| one_of | |
| np.arange(10 * 5 * 3 * 2).reshape | |
| self.currentEncryptions.setKeys | |
| subtitles_filename | |
| torch.from_numpy(vid_tensor[i, :, :, :, :]).permute | |
| self.g.vs.select | |
| torch.arange | |
| NpzFormat | |
| Feature | |
| encode_oid | |
| self.connector._get_device_link | |
| np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]], dtype=np.float32).reshape | |
| invres | |
| s.put_abs | |
| s3_backend.store_result | |
| filters.ChainingRegExpFilter | |
| get_random_words | |
| f1.create_hard_link | |
| self.proc | |
| MutableSeq('GGGTGGTAGGG').count_overlap | |
| _utils.valid_kwargs | |
| result.project.join | |
| self._create_resources | |
| are_values_different | |
| Perm(0, 8, 15)(1, 12, 16)(2, 18, 10) | |
| options._set | |
| Foundation.NSString.alloc().initWithFormat_locale_ | |
| cron.rm_job | |
| c.rect | |
| np.mgrid[0:10, 0:10, 0:1].reshape(3, 10, 10).transpose | |
| spec.read | |
| self.__figure.add_subplot | |
| RLPType4 | |
| namedtuple('user', 'name, terminal, host, started') | |
| self._hyper4.GotoURL | |
| redis.zunionstore | |
| self._create_user | |
| bx.align.score.build_scoring_scheme | |
| client.collection_group('collectionId').where | |
| set_notebook_diff_targets | |
| TPickleV6 | |
| self.cl.set_payg_billing | |
| torus | |
| GLint * 3 | |
| data_generator | |
| np.arange(1000).reshape | |
| ctx2.__aexit__ | |
| MyExceptionWithFinickyInit | |
| root_function | |
| job.setall | |
| incron.set_job | |
| SphinxDocstring.re_param_raw.replace | |
| dc.DrawEllipticArc | |
| self._unload_params | |
| target.create_target_machine | |
| DisplaySide | |
| Perm(0, 4, 10, 6, 1) | |
| translations.ngettext | |
| collections.namedtuple('DummyConfig', ['name', 'output_path', 'container', 'timelimit', 'walltimelimit', 'memorylimit', 'corelimit', 'num_of_threads', 'selected_run_definitions', 'selected_sourcefile_sets', 'description_file']) | |
| self._make_one(parent).where | |
| cropped.crop | |
| openstack_config.set_ | |
| docformatter.has_correct_length | |
| self._mock_stack_event | |
| self.grid.reshape | |
| Geodesic.WGS84.Direct | |
| SubSlotted | |
| errors.get_mysql_exception | |
| conn.create_dbinstance | |
| utils.build_reference | |
| awsclient.publish_layer | |
| adhoc_cli._play_ds | |
| y.reshape(n, out_h, out_w, out_c).transpose | |
| machine.add_transition | |
| cephes.mathieu_sem | |
| conn._examine_output | |
| mine | |
| redis.geohash | |
| auth_value.replace | |
| redis.setbit | |
| assert_min_max | |
| g.actedOnBehalfOf | |
| Geodesic.WGS84.DirectLine | |
| self.checkShift | |
| product | |
| orig_hostname.replace | |
| readFile | |
| adatetime | |
| np.arange(6)[::-1].reshape | |
| Template | |
| TAPTestResult | |
| pm.Binomial | |
| HypergeometricDistribution | |
| query.TermRange | |
| db.date | |
| SuggestItem | |
| Foundation.NSDictionary.alloc().initWithObjectsAndKeys_ | |
| rtd.project_create | |
| img.motion_blur | |
| gen_simple_poisson | |
| Notify | |
| Perm(0, 7, 9)(1, 11, 4)(2, 8, 3) | |
| Perm(0, 3, 9) | |
| torch.rand | |
| mysql.ENUM | |
| drac.set_permissions | |
| mock_create.assert_called_once_with | |
| sp.rand | |
| redis.getrange | |
| a.block_safe | |
| current_rule.next.next.matches | |
| t.on_color_rgb | |
| importutils.import_versioned_module | |
| elasticsearch.NotFoundError | |
| mock_client.create_blob_from_text.assert_called_once_with | |
| cephes.bdtr | |
| prompt_user | |
| f1_2 | |
| requireSocket | |
| self.head_weights_proj(attention_probs.permute(0, 2, 3, 1)).permute | |
| guide.handle_error | |
| PlanimeterTest.polygon.TestPoint | |
| cost.xbutton | |
| New | |
| web.config | |
| layout_slider.setContentsMargins | |
| bf.incrby | |
| bcu.NamedColor | |
| user_exit.text | |
| diffreplace | |
| NormalGamma | |
| ctx_mgr.__exit__ | |
| self.handler.handle_retries | |
| testvars.snapshot_test.format | |
| winutils.get_new_event | |
| ABC | |
| conv.im2col_cpu(up_y, self.kh, self.kw, self.sy, self.sx, self.ph, self.pw, cover_all=self.cover_all).transpose | |
| stor.LU.bld_ref | |
| Step | |
| getr | |
| observer.get_maintainer | |
| bf.set('u8', 8, 255).incrby | |
| smart_open.utils.clamp | |
| builder.add_ceil | |
| regex.search('(?V1)((a)(?1)|(?2))', 'a').group | |
| self.config_helper.get_valid_value | |
| Perm(0, 16, 7)(1, 10, 11)(2, 5, 17)(3, 14, 18)(4, 15, 12) | |
| fixedFloatFactory | |
| cairo_ctx.set_source_rgb | |
| UnknownSeq(12, character='X').count_overlap | |
| uwsgi.sharedarea_inc32 | |
| option.match | |
| Perm(0, 1, 2, 3, 4)(5, 6, 7, 8, 9)(10, 11, 12, 13, 14) | |
| umt.test_signature | |
| build.BuildSource | |
| OK | |
| m._uranus_magnitude | |
| ellipse_perimeter | |
| SubDate | |
| a.insert | |
| hwz.dimshuffle | |
| self.theme.get_config | |
| host_config_incompatible_error | |
| np.arange(50000, 50100, 10).reshape | |
| netscaler.servicegroup_server_add | |
| mgr.__exit__ | |
| vi_pos_find_char_backward | |
| minorticksubplot | |
| Perm(1, 4, 5)(2, 9, 10)(3, 14, 6)(7, 13, 16) | |
| second_handler.emit.assert_called_with | |
| misc._format_number | |
| CloudPakForDataAuthenticator | |
| zip | |
| sc.hyp1f1 | |
| gen_ol(impl4) | |
| self.vboxlayout.setContentsMargins | |
| r.setbit | |
| self.glob | |
| MockResponse | |
| pygame.color.Color | |
| cr.rectangle | |
| scene.setSceneRect | |
| np.repeat(np.int16(1), 24).reshape | |
| ctrl.scroll | |
| wx.FileTypeInfo | |
| self._set_cookie | |
| namespace.setGeometry | |
| netscaler.servicegroup_server_disable | |
| self.db.get | |
| version.SemanticVersion | |
| res.smoothed_state_autocovariance(-2, end=mod_oos.nobs - 1, extend_kwargs=extend_kwargs).transpose | |
| self.base_error.format | |
| qs.select_related('permission__codename').values_list | |
| CacheKey | |
| kerns.dimshuffle | |
| error.BaseError | |
| boto_route53.update_record | |
| nx.k_random_intersection_graph | |
| self.partition_utils.make_partition | |
| self._api.replace | |
| BaseQuery | |
| a.copy_block | |
| np.array([[1, 2, 3], [3, 2, 1]], dtype=np.uint8).reshape | |
| ctx.config.set_value | |
| doc.replace | |
| numpy.fromfile(datafiles('rgb.bin'), dtype='<f4').reshape | |
| CT_Table.new_tbl | |
| g | |
| ClassNew | |
| build.get_target_configuration | |
| euclid.Point3 | |
| vectorized_is_trivial | |
| quadratic_congruence | |
| v1.rotate | |
| Perm(0, 10, 7)(1, 5, 6)(2, 4, 11) | |
| sphere | |
| GuessProxyAuth | |
| TestTuple | |
| self.c.basic_qos | |
| DatetimeGregorian | |
| optionalcascade | |
| nparr.reshape | |
| path1.ensure | |
| flags.DEFINE_string | |
| ndindex | |
| self.c._on_get_ok.assert_called_with | |
| self.w.cell | |
| Myself | |
| i18n.CatalogInfo | |
| dyld.dyld_framework | |
| LibraryDescriptor | |
| LEFieldLenField | |
| conn.describe_workflow_execution.when.called_with | |
| CFNetwork.CFNetServiceCreate | |
| Perm(0, 14, 10)(1, 9, 16)(2, 13, 17)(3, 19, 11)(4, 15, 6) | |
| c.get_object | |
| mu.emu_start | |
| np.arange(2 * 3 * 5).reshape | |
| pgl.glClearColor | |
| val[1:].replace | |
| client.collection | |
| elliprg | |
| create_user | |
| self.cache.store | |
| soup.a.insert_after | |
| file_client.append_data | |
| np.concatenate((res_oos.smoothed_state_cov, res_oos.predicted_state_cov[..., -1:]), axis=2).transpose | |
| HTTPError | |
| m4.scale | |
| CoreFoundation.CFRunLoopRunInMode | |
| foo | |
| github2.get_issue | |
| scipy.stats.fisk | |
| cls.config.get | |
| key | |
| BITBUCKET.is_default_reviewer | |
| inst.response_header | |
| self._impersonate_helper | |
| c.copy_object | |
| javabridge.make_method | |
| np.arange(24, dtype='i4').reshape | |
| svglib.Box | |
| Greater | |
| exercise_graceful_test_service | |
| ui.setconfig | |
| create_pandas_abc_type | |
| securesystemslib.gpg.functions.verify_signature | |
| objc.macos_available | |
| stem.connection.IncorrectCookieValue | |
| cephes.nbdtrik | |
| self.iso | |
| self.os.path.join | |
| array.argsort | |
| stem.util.system.CallError | |
| type(self) | |
| table2.iterrows | |
| astmodels.ExponentialCutoffPowerLaw1D | |
| nameTable.setName | |
| testdir.runpytest | |
| cms.cms_verify | |
| table.denormalize | |
| request.route_url | |
| theme.get_config | |
| self.alloc_wo_dep.dimshuffle | |
| Upload | |
| TokenBucketLimiter | |
| getattr(g, func) | |
| zypper_mock.assert_any_call | |
| VersionInfo | |
| decaying | |
| DNSText | |
| recattrs.RecordLevel | |
| MixedLMParams | |
| BaseSlidePart | |
| ax[m, n].plot | |
| api.position_of_radec | |
| mode_with_gpu.including | |
| Perm(0, 10, 17, 12, 3)(1, 6, 11, 7, 2) | |
| Employee.objects.annotate(lead=Window(expression=Lead(expression='salary'), order_by=[F('hire_date').asc(), F('name').desc()], partition_by='department')).values_list | |
| self.instance.issue | |
| arange(40).reshape | |
| res.smoothed_state_autocov.transpose | |
| RandomMatrixSymbol | |
| inp1.dimshuffle | |
| StratifiedShuffleSplit | |
| cephes.bdtri | |
| self.performSelectorOnMainThread_withObject_waitUntilDone_ | |
| Uniform | |
| self._get_argument_value | |
| BigIP | |
| root.info | |
| cephes.gdtr | |
| A.get_edge | |
| target.replace | |
| search.HyperbandEarlyTerminate.init_from_max_iter | |
| ufloat | |
| helper.render_view | |
| self.ds.add_dimension | |
| Perm(0, 3, 9, 10, 5) | |
| t.suggest_discrete_uniform | |
| api_client.getTestSuiteCustomFieldDesignValue | |
| r.lset | |
| h2.stream.H2Stream | |
| client_context.create_user | |
| Matrix.diag | |
| ic_sig | |
| vertex | |
| wx.KeyboardState | |
| BITBUCKET.get_pipeline_steps | |
| _make_fire | |
| G.has_edge | |
| Transformation | |
| self.lua.table | |
| arr.transpose | |
| req.requestReceived | |
| xmpp.send_msg | |
| Matrix | |
| r.smove | |
| self.t1.jd1.reshape | |
| repo.wwrite | |
| session.run | |
| self._attr | |
| ScalingField | |
| self._data_stub_internal.__exit__ | |
| T.basic.batched_dot(grad_op, gradients.dimshuffle(1, 0, 2)).dimshuffle | |
| self.SetReadOnly | |
| vbox.setContentsMargins | |
| RequirementSet.create_path | |
| self.__owm.weather_at_places | |
| QMessageBox.critical | |
| self.proto.sendDebug | |
| Student | |
| self._headers | |
| checkrgb | |
| self.__test_instance.uvindex_history_around_coords | |
| config.getint | |
| _strip_extras.create_path | |
| Resolver.create_path | |
| pu.Channel | |
| etgtools.PropertyDef | |
| _SofMarker | |
| grid.SetReadOnly | |
| gdata.gauth.OAuth2Token | |
| mock_stack | |
| self.parse_until_text | |
| valueForName | |
| self.api.getTestCaseCustomFieldTestPlanDesignValue | |
| linux_lvm.lvresize | |
| sa_exc.OperationalError | |
| self.authreq.addExtensionArg | |
| callop | |
| self._loader.path_dwim_relative | |
| _default_root.tk.call | |
| peak.SetRangeValue | |
| T | |
| QtGui.QGraphicsRectItem | |
| er.get_ifd_dict | |
| chainer.serializers.save_hdf5 | |
| smprop.binom_tost_reject_interval | |
| U | |
| g.wasDerivedFrom | |
| debconfmod.set_ | |
| self.translations.dungettext | |
| torch.randn | |
| W2.dimshuffle | |
| Timestamp.fromisocalendar | |
| instance.search_satellite_imagery | |
| self.client.status | |
| y1.permute | |
| pgl.glColor4f | |
| r.execute_command | |
| rows[1].set_cell | |
| g.inv | |
| ipc.HTTPTransceiver | |
| _adjust_completion_text_based_on_context | |
| TagMatcher.make_category_tag | |
| cv.cuda.evenLevels | |
| flexmock(foo).should_receive('bar').with_args | |
| sql_ctx.createDataFrame(metrics).toDF | |
| Foundation.NSException.raise_format_ | |
| self.change_roots | |
| it.prepend | |
| cmd.cli_ctx.config.get | |
| img.pseudo | |
| _count_paths_outside_method | |
| np.random.gamma | |
| parse_error | |
| target.dimshuffle | |
| self.given_now | |
| mat_func | |
| client.foo | |
| NN | |
| RedditErrorItem | |
| redis.zremrangebyscore | |
| UsesColor | |
| Perm(0, 10, 17, 12, 3) | |
| d22 | |
| cmd.cli_ctx.config.set_value | |
| cl.set | |
| mock_context.load_verify_locations.assert_called_once_with | |
| "'{0}' is an invalid value for attribute {1}.{2}".format | |
| datetime | |
| self.get | |
| trial.suggest_uniform | |
| self.host.utils.SubprocessException | |
| xmlsec.tree.find_child | |
| multicall.d.multicall2 | |
| query_queue[1].put | |
| special.lpmv | |
| mi.numeric_range | |
| shapes.Circle | |
| web.strip_between | |
| self.A.startswith | |
| asbool | |
| testing.fails_on_everything_except | |
| errors.ReadTimeoutError | |
| wx.TimeSpan | |
| soup.b.insert_after | |
| v3_migrate_mock.assert_called_once_with | |
| ephem.readtle | |
| Perm(0, 14, 10) | |
| m.pos_only_def_mix | |
| db.add_pername | |
| mock_datetime | |
| SameQ | |
| DBAPITypeObject | |
| _eta_range | |
| gradients.dimshuffle | |
| fig_ref.add_subplot | |
| cbook._rename_parameter | |
| dog.set | |
| Array([1] * 2 ** 4).reshape | |
| TextRange | |
| context_layer.permute | |
| alternatives.install | |
| s1.is_equiv | |
| gen_ol(impl2) | |
| self._update_progress | |
| pat_matrix | |
| list_output | |
| res.permute | |
| self.block_device_type.endElement | |
| type(index[0]) | |
| UsernamePasswordCredential | |
| pgdb.Interval | |
| array._ext.getitem_range | |
| QRadialGradient | |
| DataFrameClient | |
| redis.hset | |
| VolumeFromSpec | |
| MountInfo | |
| gauss_jacobi | |
| self._api.SetRectangle | |
| self.translations.npgettext | |
| yee_transitions.pulse | |
| t.variables[0]._label_path_expansion | |
| self.client.ctcpQuery_VERSION | |
| glue | |
| Perm(0, 4, 9, 14, 5)(1, 3, 13, 15, 10) | |
| pytest.mark.wycheproof_tests | |
| cheby2 | |
| conn.build_base_http_request | |
| system | |
| TestObject.objects.extra(select={'foo': 'first', 'bar': 'second', 'whiz': 'third'}).values | |
| bezierPath.cubicTo | |
| self.dbnd_context_manage.__exit__ | |
| cm2.__exit__ | |
| Captured | |
| _TEST_UUID_STR.replace | |
| encipher_bifid | |
| Tier | |
| SessionCommandMixin.create_path | |
| Perm(0, 6, 8)(1, 7, 2) | |
| FfmpegFormat | |
| self.new_query().select | |
| MovedModule | |
| widget.layout().setContentsMargins | |
| try_compile_bad_optional | |
| enumeration | |
| render_field_from_tag | |
| m.matrix | |
| a.cut | |
| self.dataset_hm.add_dimension | |
| sm.distributions.zinegbin.cdf | |
| XStrFixedLenField | |
| patches.Arrow | |
| sm.distributions.zigenpoisson.pmf | |
| elt_ctx.__exit__ | |
| awsclient.service_principal | |
| np.array([1, 2, 5, 6], dtype=np.float32).reshape | |
| mock.call.open().__exit__ | |
| LCHabColor | |
| self.page.select | |
| self.check_stubs | |
| CommandError.create_path | |
| np.arange(24, dtype=dtype).reshape | |
| atomics[db_name].__exit__ | |
| ' {0:10} {1:20} {2:12} {3}'.format | |
| Range1d | |
| Employee.objects.annotate(nth_value=Window(expression=NthValue(expression='salary', nth=2), order_by=[F('hire_date').asc(), F('name').desc()], partition_by=F('department'))).order_by | |
| CurveFp | |
| Foundation.NSSet.setWithObjects_ | |
| self._makeFile | |
| getSomeObjectAt | |
| stor.LU.bld | |
| np.arange(4 * 9).reshape | |
| obj_sm.AddService2 | |
| driver.Timestamp | |
| numpy.arange(256 * 256, dtype='uint16').reshape | |
| Item | |
| nx.thresholded_random_geometric_graph | |
| Perm(1, 4, 5) | |
| _test_retries_helper | |
| _parse_version_line | |
| r.zrem | |
| obj.pyobjc_performSelector_withObject_afterDelay_ | |
| egrep_cmd.replace | |
| GLib.Error | |
| ngettext | |
| editor_layout.setContentsMargins | |
| self._parse_rfc3339_test | |
| spherical_to_cartesian | |
| hundfn | |
| trial.suggest_int | |
| CoreText.CFAttributedStringCreate | |
| apitools_exceptions.HttpError | |
| object_.torture_signature_1 | |
| CoreFoundation.CFUserNotificationDisplayNotice | |
| enum | |
| myAWSIoTMQTTClient.configureAutoReconnectBackoffTime | |
| module.foo | |
| self.res._assoc | |
| dism.add_capability | |
| Perm | |
| c.transpose | |
| gu.reshape(B, out_H, out_W, C).transpose | |
| c.head_container | |
| partition | |
| options._cb_key_val | |
| self.rg.f | |
| hyp2f2 | |
| PrefixList | |
| rng.rand | |
| QDate | |
| cosine_sim.permute | |
| s.LogIn | |
| FakeError | |
| float_tensor[0].permute | |
| dut.api('routemaps').set_continue | |
| chainerx.eye | |
| TogoWS.entry | |
| d.transpose | |
| Foundation.NSMutableSet.setWithObjects_ | |
| testing.against | |
| self.override_settings.__exit__ | |
| make_html_guess_test | |
| s3.subs | |
| self._parallel_uploader | |
| ITE | |
| chacha.encrypt | |
| get_value | |
| ll.replacelines | |
| json.enum | |
| pd.datetime | |
| self.track.set_color | |
| Logistic | |
| conn.create_vpn_connection | |
| np.random.binomial | |
| super(SelectorSet, self).__init__ | |
| tensor.vectors | |
| array.reshape | |
| extension.create_hook_append_value | |
| self.api.getTestSuiteCustomFieldDesignValue | |
| Point3 | |
| self._xml_base.__exit__ | |
| BsdfFormat | |
| v.dimshuffle | |
| update.replace | |
| self.gitrun | |
| cmds[i].replace | |
| f1 | |
| Index | |
| regex.subn | |
| Pendulum | |
| np.expand_dims(np.expand_dims(W_X, axis=3), axis=4).transpose | |
| observe | |
| exc.DBAPIError | |
| ExtractDiag | |
| filter.cell | |
| generate_error | |
| adla_format_path.format | |
| base.set_conf | |
| _ConfigAliases.get | |
| date_range | |
| ObjectInactiveError | |
| helper.render | |
| redismod.zrange | |
| extension.Extension | |
| sf.text_to_glyphs | |
| cuda.reduce | |
| self._run_simple | |
| self.sc.reshape | |
| np.ones((7, 13, 8), np.int8)[4:6, 1:11:6, 1:5].transpose | |
| SheetWriter | |
| win32api.error | |
| log_softmax_2d_x.reshape | |
| BasicCommand.FROM_FILE | |
| sc.bdtri | |
| annotateline | |
| design.transpose | |
| p.estimate_densities | |
| http_post.ConvertSpeed | |
| httputil.ResponseStartLine | |
| wx.Point | |
| NormalFloatHyperparameter | |
| _remove_gcd | |
| logrotate.set_ | |
| s.existing | |
| self.check | |
| conn.send_email | |
| self.translations.unpgettext | |
| ScreenSaver.NSMakeRect | |
| self.with_equiv | |
| write_file | |
| getattr(w, method) | |
| add_timing | |
| m5.scale | |
| proto.write_message_begin | |
| ui.configbool | |
| thread_manager.print_msg | |
| audio.play_tone | |
| feature_A.transpose | |
| Reactor | |
| tags.Tag | |
| self.translations.ldngettext | |
| schema.SchemaField | |
| callback2.assert_called_once_with | |
| github.get_issue | |
| BitFieldLenField | |
| fn | |
| finder_layout.setContentsMargins | |
| testui.configbool | |
| trial.suggest_loguniform | |
| l2.setContentsMargins | |
| Angle.reduce_dms | |
| format_bit_size | |
| Argument | |
| self.git | |
| s3fs._get_cached_file_name | |
| np.arange(6).reshape | |
| f.enumerate_children | |
| dfa.add_transition | |
| is_nthpow_residue | |
| np.arange(24, dtype='f4').reshape | |
| SphinxDocstring.re_raise_raw.replace | |
| mat.transpose | |
| torch.zeros | |
| Time | |
| self.h5file.set_node_attr | |
| unittests.common.bucket().post_vod_playlist | |
| expected.transpose | |
| xp.reshape | |
| Foundation.NSMutableSet.alloc().initWithObjects_ | |
| k.permute | |
| logger.debug | |
| self.sc.data.lon.reshape | |
| splitter.setContentsMargins | |
| cs.services.disable_log_reason | |
| get_win | |
| CLinker().accept(g).make_function() | |
| objc.createStructType | |
| swiftclient.client.head_container | |
| utils.print_warning | |
| register_opt | |
| PowerFunction | |
| func.foobar | |
| function | |
| AxisLabel | |
| feedgenerator.Rss201rev2Feed | |
| rdh.get_nexus3_catalog | |
| FileCache | |
| conn.forward_local_port | |
| ABI | |
| open('README.rst').read().replace('|Build Status|', '', 1).replace | |
| xsd.date | |
| cli.config.get | |
| tr.connection.execute | |
| awsclient.get_sdk_download_stream | |
| sass.SassColor | |
| opt.make_vector | |
| the_cache.set | |
| run_tests.TTest | |
| msg.attach | |
| foo1.foo | |
| all_people.filter(age__lt=10).defer | |
| transaction.__exit__ | |
| _get_gcp_environment_credentials | |
| Or | |
| config_builder.set_option | |
| login.assert_called_once_with | |
| np.arange(1, 1 + dst.size).reshape | |
| self.wc.request | |
| EnvironmentError | |
| namedtuple('vmem', 'total available percent used free active inactive buffers cached shared') | |
| out.note_on | |
| Nor | |
| x509.IssuingDistributionPoint | |
| LeviCivita | |
| r.mget | |
| mixer.pre_init | |
| pm.Normal | |
| LogAttrs | |
| np.array([1.5, 1.5, 2.5, 2.5, 3.5, 3.5], dtype=np.float32).reshape | |
| random.normal | |
| drac.set_network | |
| self.lua.execute | |
| mock_token.assert_called_once_with | |
| gen_data | |
| server_conn.simulate_dh_gex_reply | |
| ImportationFrom | |
| Beam | |
| np.array(np.arange(24)).reshape | |
| '{:>20} {:>25} {:>15}'.format | |
| true_obliquity | |
| AppKit.NSEdgeInsetsMake | |
| chainermn.datasets.scatter._scatter_index | |
| PlusMinus | |
| self.MyColor | |
| self.locales._compute_filename | |
| RAWINPUTDEVICE | |
| self.service_connection.publish | |
| planar2.scale | |
| np.arange(1, 25, dtype=self.dt).reshape | |
| result.foo | |
| self._repr_options | |
| sm.distributions.zipoisson.pmf | |
| ag.Categorical | |
| libcloud_storage.get_container_object | |
| fh.validate | |
| bf.set('u8', 8, 254).overflow('fail').incrby('u8', 8, 2).incrby('u8', 8, 1).incrby | |
| formatsig | |
| A.reshape | |
| module.replace | |
| self.frame_writer | |
| s.add_field | |
| self._conn.attach_x11_listener | |
| PrintLoggerFactory() | |
| thread.SessionThread | |
| cftime.DatetimeNoLeap | |
| np.arange(120, dtype='d').reshape | |
| slow_intro_conn.fetchval | |
| np.arange(20).reshape | |
| hue_pal | |
| ExcludeRangeValidator | |
| connection.__aexit__ | |
| self.h5file.move_node | |
| requests.AckRequest | |
| self._test_filter2 | |
| URLLib3ReadTimeoutError | |
| Silence | |
| l.rename_s | |
| BestVersionAlreadyInstalled.create_path | |
| SimpleModel.objects.all().values_list | |
| wx.MessageDialog | |
| MethodTest.TestObjectParamsArg | |
| _GlueSpec | |
| self.server.addConnection | |
| importutils.import_object | |
| self.splitextTest | |
| Regress.TestObj().skip_return_val | |
| consumer.gossip.election.assert_called_with | |
| FAVORITE_HASH.create_path | |
| Among | |
| httppeer.httpv2peer | |
| self._ctx.__exit__ | |
| pm.gp.cov.Periodic | |
| src.find_first_text | |
| _parser.reducer | |
| driver.Time | |
| table.iterrows | |
| db.get_pername | |
| FakePopen | |
| link.set_color | |
| BubbleSeriesData | |
| DEV_PKGS.create_path | |
| dt.time | |
| neibs.dimshuffle | |
| py_datetime.time | |
| line_aa | |
| one | |
| v._semi_path_expansion | |
| editor.sync_value | |
| Arrow | |
| dialer.add_transition | |
| mainWindow.setGeometry | |
| CandidatePreferences.create_path | |
| RepresentationMapping | |
| ReportPortalService | |
| termui.decorate | |
| jacobi | |
| ec.assert_ | |
| Perm(0, 5, 1)(2, 4, 6)(3, 10, 7) | |
| parametrize_test_working_set_resolve | |
| self.builder.string_build | |
| mr_job.increment_counter | |
| Operator | |
| build.create_path | |
| mahotas.as_rgb | |
| self.checkFloatType | |
| HorizontalExpander().register | |
| ds.get_filename | |
| G.get_edge_data | |
| repo.ui.config | |
| myconn.Time | |
| widget.drag_check_threshold | |
| BITBUCKET.stop_pipeline | |
| self.rg.wald | |
| img.modulate | |
| bde.TitleChangedEvent | |
| queue.put | |
| Perm(11)(1, 2, 3, 4, 5) | |
| GammaInverse | |
| self._call_fut | |
| dialog.add_buttons | |
| self.init_poolmanager.assert_called_once_with | |
| MetricInfo | |
| UpYunServiceException | |
| ContentRange | |
| flags.DEFINE_bool | |
| hp.normal | |
| indexedarray3.sort | |
| image.SetMaskColour | |
| datetime.datetime | |
| DagumDistribution | |
| djangomod.collectstatic | |
| filters.EnvFilter | |
| RendererAgg | |
| errorlog.error | |
| r.hmget | |
| Index.argument_for | |
| self.driver.ex_create_security_group | |
| path.arcTo | |
| mergemod.updateresult | |
| uwsgi.sharedarea_dec32 | |
| get_long_docs | |
| fsa.rows[0].setslice_with_length | |
| self._get_repo | |
| arange(24, dtype='i4').reshape | |
| djangomod.createsuperuser | |
| one_more_ws.write | |
| Trait | |
| django.core.validators.RegexValidator | |
| Xnor | |
| ms | |
| _GetPartitionInfo | |
| BetaBinomialDistribution | |
| transfer.upload_file | |
| FsMock | |
| self.check_fatal_error | |
| self.p.notice | |
| Connection | |
| CoreFoundation.CFArrayCreateMutable | |
| types.ServiceConfig | |
| sc.bdtr | |
| CallSite | |
| _complete | |
| package_file.Hexdigest | |
| self._begin_impl | |
| makeGetpass | |
| param.depends | |
| win.dispatch | |
| dget | |
| Array.zeros | |
| y.reshape(B, out_H, out_W, C).transpose | |
| Account | |
| kern.dimshuffle | |
| Nand | |
| Person | |
| Description | |
| self.execute | |
| Laplace | |
| super(UnparsableProtocol, self).__init__ | |
| self.s2.reshape | |
| funcs._mpmath_kraft_burrows_nousek | |
| d.crop | |
| TSC.ConnectionCredentials | |
| np.expand_dims(np.expand_dims(np.expand_dims(P_X, axis=2), axis=3), axis=4).transpose | |
| theano.compile.get_default_mode().including | |
| Permutation(0, 3, 5, 4) | |
| randX | |
| xmlsec.tree.find_parent | |
| sqlalchemy.Enum | |
| TestClass | |
| static_call | |
| seldlg.text | |
| cemu.writeAt | |
| BaseClient | |
| res.smoothed_state_autocovariance(1, start=8, end=9).transpose | |
| QGraphicsRectItem | |
| self.driver.ex_reinstall_server_image | |
| fails_on_everything_except | |
| URL.fromText('http://example.com/a/b').child | |
| schedules.crontab | |
| redis.lrem | |
| codecs.open | |
| addflag | |
| self.templateNoOscillations | |
| windows.gaussian | |
| ops.cp_column | |
| self.list.SetItemOverFlow | |
| 'solar_event: {0} ({1}, {2})'.format | |
| boto_route53.get_record | |
| get_vol_info | |
| self.gl.glClearColor | |
| self.actions.append | |
| check_col | |
| colors.PCMYKColor | |
| any_permission_required | |
| registry.register | |
| np.arange(2 * 7 * 5).reshape | |
| node.text.replace | |
| cv.moveWindow | |
| col['field'].replace | |
| obj.__exit__ | |
| Origin | |
| fuzzy.FuzzyInteger | |
| Format | |
| f1.append_data | |
| t.dngettext | |
| dns.Record_HINFO | |
| check_tags | |
| box | |
| txn.__exit__ | |
| arange(27)[::-1].reshape | |
| pxd | |
| obj.pyobjc_performSelectorOnMainThread_withObject_waitUntilDone_modes_ | |
| QtGui.QInputDialog.getDouble | |
| sheet_a.write | |
| cov.__exit__ | |
| c.queue_bind | |
| self._warnings_manager.__exit__ | |
| fieldsDef | |
| _make_subparam | |
| panel.setContentsMargins | |
| wx.html.HtmlBookRecord | |
| PostRotateXYTwist | |
| redis.migrate_keys | |
| self.s3.obstime.reshape | |
| FakeValue | |
| wcs.pixel_to_world_values | |
| foo2 | |
| redis.zremrangebyrank | |
| Hashids | |
| self.service_connection.create_customer_gateway | |
| model_to_screen | |
| get_config_data | |
| overlay_cr.set_source_rgb | |
| date | |
| types.ServicePort | |
| az_cli.config.getboolean | |
| TrapezoidalDistribution | |
| self.check_tokens | |
| self.classes | |
| gaussian_reduce | |
| client.bulk_import_upload_part.assert_called_with | |
| prediction.select | |
| run_step | |
| np.array(primes[:2 * 3 * 5], dtype=np.int64).reshape | |
| PrependedAppendedText | |
| callback3.assert_called_once_with | |
| euclid.Vector3 | |
| self.g.maxflow_value | |
| np.arange(3 * 4 * 5 * 6).reshape | |
| ArrayType.zeros | |
| register_backend | |
| t.suggest_loguniform | |
| C.objects.all().only | |
| backend.cuda.elementwise | |
| dns.Record_RP | |
| ValidationErrorData | |
| path.replace | |
| credentials.Credentials | |
| self.check_input_tty | |
| urllib.quote(x.encode('utf-8')).replace('%2C', ',', 'g').replace('%3A', ':', 'g').replace('%40', '@', 'g').replace('%24', '$', 'g').replace('%2F', '/', 'g').replace | |
| T1 | |
| Address | |
| expr._random | |
| np.arange(120, dtype=np.float64).reshape | |
| CType | |
| cls1.reshape | |
| feedgenerator.Atom1Feed | |
| djangomod.command | |
| self._sock_operation | |
| Bbox.from_extents | |
| np.linspace(-10, 0, 5 * 10 * 15).reshape | |
| stats.hypergeom | |
| builder_elsebranch.add_activation | |
| xml.etree.ElementTree.XMLParser | |
| wx.FlexGridSizer | |
| mock_lock.assert_called_once_with | |
| package.replace | |
| urllib.quote(x.encode('utf-8')).replace('%2C', ',', 'g').replace('%3A', ':', 'g').replace('%40', '@', 'g').replace('%24', '$', 'g').replace | |
| da.transpose | |
| duo_client.admin.Admin | |
| s.backup | |
| WebsocketMock | |
| stats.binom.pmf | |
| Ed25519Extension | |
| self._assert_impl_steps | |
| x.view | |
| ws.write | |
| main_layout.setContentsMargins | |
| fs.read_block | |
| bm.set_block | |
| cls.waffle_patcher.__exit__ | |
| get_library | |
| unittest.TestLoader().discover | |
| Wigner3j | |
| self.ftest | |
| InstallationCandidate.create_path | |
| s | |
| PlistByteCounts | |
| self.conn._on_tune | |
| channel.basic_qos.assert_called_with | |
| cftime.DatetimeGregorian | |
| f4 | |
| Station | |
| stdin.channel.exit_with_signal | |
| _shortened_many | |
| cairo.SVGSurface | |
| get_tags.create_path | |
| fx_wand.push_pattern | |
| np.arange(10 * 7 * 11).reshape | |
| BrokerMetadata | |
| _BaseDrawingOperation | |
| _dict_of | |
| ScoreSummary.objects.filter(student_item__course_id=course_id, student_item__student_id=student_id).select_related | |
| data.mul(255).clamp(0, 255).byte().permute | |
| dut.api('routemaps').delete | |
| ProxySettings | |
| Measurement | |
| BernoulliDistribution | |
| DataElementPlus | |
| sa.dialects.registry.register | |
| Perm(0, 7, 13) | |
| filter.method | |
| get_user_model().objects.create_user | |
| self.topLayout.setContentsMargins | |
| self.driver.ex_add_client_to_target | |
| tmpdir.join | |
| root | |
| va.method | |
| np.arange(120).reshape | |
| gen_crossed_logit_pandas | |
| DataType | |
| mock_remove_disk.assert_called_once_with | |
| MockSearchResult | |
| model.transform(test).select | |
| ProcessCommunicationStderrEvent | |
| ExitPolicy | |
| inst.globaltrace | |
| painter.drawLine | |
| self.ureg.convert | |
| self.compressor.construct_asset_path | |
| fileh.create_group | |
| get_config().set | |
| context.set_source_rgba | |
| stem.connection.UnreadableCookieFile | |
| atoms.path | |
| np.arange(5 * 5 * 5).reshape | |
| self.wrong_type | |
| self.ag.update | |
| qs1.difference(qs2).values_list | |
| mtransforms._make_str_method | |
| self.service_connection.create_subnet | |
| x_hat.transpose | |
| Security.AuthorizationCreate | |
| cython.test_assert_path_exists | |
| stats.sample_size_necessary_under_cph | |
| print_stats | |
| UsmUserData | |
| rpm.checksum | |
| FnApiUserStateContext | |
| gflags.DEFINE_boolean | |
| TestPickle33 | |
| make_full | |
| array4.sort | |
| s.add_transition | |
| SummaryMetric | |
| Perm(0, 16, 7)(1, 10, 11)(2, 5, 17)(3, 14, 18) | |
| un_incr_digits | |
| gflags.DEFINE_string | |
| qp | |
| hidden_states.permute | |
| Sub2Block | |
| self.setContentsMargins | |
| Test.PublicArrayTest.__setitem__ | |
| sm.distributions.zipoisson.moment | |
| Entity | |
| hg.pull | |
| Rect.from_point | |
| PurePath | |
| g.mincut | |
| display.set_edge_style_attribute | |
| load_backend | |
| etcd_mod.set_ | |
| cephes.gdtrc | |
| stats.norm.rvs | |
| fractions | |
| pytester.runpytest_subprocess | |
| RequirementTracker.create_path | |
| UnackedData | |
| q.replace | |
| gb.indicate_mechs_by_attrs | |
| option_context | |
| InstanceGroup | |
| self.assertEqualNumberAndUnit | |
| ureg.convert | |
| pg.Vector | |
| acov.transpose | |
| self._makeSet | |
| table.limit | |
| x[:, :, 10:30, ::i].dimshuffle | |
| nso.JsonRpc | |
| G.dimshuffle | |
| s.new_task | |
| res.smoothed_state_autocovariance(2).transpose | |
| ws1.write | |
| pd.RangeIndex | |
| FormatControl.create_path | |
| LifeForm | |
| c.crypto_box_open_afternm | |
| SelectionPreferences.create_path | |
| cv.detail_BestOf2NearestRangeMatcher | |
| QtCore.QLineF | |
| template_dynamic_sync | |
| self.i.__exit__ | |
| repo.ui.configint | |
| store.get_store().should_receive('put').once().with_args | |
| network.ip_addrs | |
| build_scoring_scheme | |
| img.crop | |
| Perm(0, 7, 13)(1, 12, 9)(2, 8, 4)(5, 11, 19) | |
| Perm(0, 5, 1) | |
| eCTs | |
| subprocess.CalledProcessError | |
| call.Foo().meth | |
| hp.randint | |
| _build_safe_cmp_func | |
| Site.objects.select_related('root_page', 'root_page__locale').order_by | |
| super(InvalidSuperChecks, self).function | |
| function_trace.__exit__ | |
| c.delete_object | |
| association.Association.fromExpiresIn | |
| nd.reshape | |
| Perm(0, 5, 10, 6, 1)(2, 4, 14, 16, 11)(3, 9, 15, 17, 7) | |
| vi_pos_find_char_forward | |
| Foundation.NSOrderedSet.alloc().initWithObjects_ | |
| catalogue.check_exists | |
| self.rg.hypergeometric | |
| self.service_connection.create_vpc_peering_connection | |
| list_builder.construct_list | |
| Perm(1, 3, 4) | |
| pyxb.utils.utility.Location | |
| ptn.add_color_stop_rgba | |
| cmd.message | |
| s3.upload_part | |
| self.label_container.layout.setContentsMargins | |
| dism.add_feature | |
| inner | |
| vpython.vec | |
| entrypoints.EntryPoint | |
| models.n_link_pendulum_on_cart | |
| self.setTextMargins | |
| self.generate | |
| gz.dimshuffle | |
| text | |
| merge_sorted | |
| c.event | |
| btrfs._set_default | |
| compile_restricted | |
| feature_B.transpose | |
| a.elementary_row_op | |
| self._run_throughput_test | |
| MethodTest.TestStringParamsArg | |
| self.vmops.guest_deploy | |
| Perm(0, 4, 5) | |
| c.setFillColorCMYK | |
| jday | |
| zk_concurrency.lock | |
| arg.replace | |
| 'projects/{}/datasets/{}/tables/{}'.format | |
| fmt2.format | |
| libcloud_loadbalancer.balancer_detach_member | |
| boolean_flag | |
| pattern.add_color_stop_rgb | |
| c.crypto_box_open | |
| OpenSSL.crypto.X509Extension | |
| beam.metrics.cells.DistributionData | |
| interval | |
| ldflag.replace | |
| draw.line | |
| CMod | |
| g.dimshuffle | |
| datatypes.TimeZone | |
| template_animate_output_dynamic | |
| np.arange(10.0 * 20.0).reshape | |
| named | |
| self.good_comment.matches | |
| mock.call.sqlite | |
| SourceDistribution.create_path | |
| c | |
| monitor.secure_monitor_server | |
| matchpyWC | |
| dism.capability_installed | |
| ir.Loc | |
| (x_hat - rhs).transpose | |
| globals_import_from | |
| whitw | |
| z_crop.transpose | |
| uf.union | |
| cephes.fdtrc | |
| aicc | |
| self.api.getRequirementCustomFieldDesignValue | |
| Param | |
| self.assert_match | |
| self.name().replace | |
| DummyFieldStorage | |
| special.lqmn | |
| path1.join | |
| sftp.chown | |
| self.sc.obstime.reshape | |
| cs.group_types.update | |
| RowRange | |
| QLinearGradient | |
| awsclient.service_principal.assert_called_once_with | |
| iniparser.ParseError | |
| LROPoller | |
| stem.connection.IncorrectCookieSize | |
| self.cs.services.disable_log_reason | |
| self._hyper2.SetUnderlines | |
| text.rindex | |
| bcrypt.kdf | |
| typer.Option | |
| pattern.set_corner_color_rgb | |
| td.put | |
| PlistTrailer | |
| KeyValue | |
| python_golf | |
| WeightedMinHashGenerator | |
| v.mset | |
| t.AddAccessedProperty | |
| cftree | |
| BernoulliProcess | |
| self.config | |
| MPI.Grequest.Start | |
| install_req_from_req_string.create_path | |
| gen_crossed_logit | |
| make_option_group.create_path | |
| kid_rsa_private_key | |
| eigvectors.transpose | |
| op._widen_uninterr.__exit__ | |
| posixpath.join | |
| t | |
| self.pdc.DrawRoundedRectangle | |
| conn.forward_remote_port | |
| client.set_cookie | |
| arange(4).reshape | |
| CoreFoundation.CFUserNotificationDisplayAlert | |
| bce.enumeration | |
| Perm(19)(0, 6, 2)(3, 5, 11) | |
| bbox | |
| self._compare | |
| np.arange(4 * 500 * 500).reshape | |
| LenField | |
| self.item.shift | |
| CustomTimeDepKetMultipleLabels | |
| self.check_bootstrap | |
| tag.comments.set | |
| ellipord | |
| self.A.count | |
| zypper_mock.noraise.call.assert_called_with | |
| Point2 | |
| virt.volume_upload | |
| self.__owm.forecast_at_coords | |
| res.smoothed_state_autocovariance(-1, end=mod_oos.nobs, extend_kwargs=extend_kwargs).transpose | |
| conv_map_tuple | |
| np.random.rand | |
| TargetPython.create_path | |
| kegg_find | |
| layout.setContentsMargins | |
| model.IPPermission | |
| _run_all | |
| td.tail | |
| mocked_db_creation.return_value.destroy_test_db.assert_called_once_with | |
| self.get_parameter_documentation_from_service | |
| testvars.delete_proto.format | |
| nx.generators.directed.random_k_out_graph | |
| cephes.obl_rad1 | |
| ExtensionFrame | |
| MYCOLOR | |
| self.create_browsefile | |
| ts.tdb | |
| Location | |
| test_slice | |
| pg.mkPen | |
| util.available_parsers | |
| MP4FreeForm | |
| torch.ones | |
| _down | |
| pkg.join | |
| replace_in_file | |
| logspace | |
| repo.put | |
| _get_prompt_text | |
| hbox.setContentsMargins | |
| e.set | |
| ActorSystemConventionUpdate | |
| parse.search | |
| TPickleV7 | |
| mibInstrumController.mibBuilder.importSymbols | |
| matchoutput | |
| t.add | |
| m.dispatch.before_insert | |
| Location.objects.filter(id=5).annotate(num_cities=Count('city')).values | |
| conn.send_email.when.called_with | |
| s.machine.add_transition | |
| sb.init_residue | |
| _register_one_provider | |
| sm.distributions.zinegbin.logpmf | |
| self._syscall | |
| torch.Tensor | |
| sympy.MatrixSymbol | |
| mock.assert_called_once_with | |
| l.reshape | |
| str.maketrans | |
| types.ServiceSecret | |
| design.ViewDefinition | |
| h.permute | |
| TSetting | |
| google.api_core.gapic_v1.method._determine_timeout | |
| circle_perimeter | |
| macdefaults.write | |
| FBComposite | |
| npgettext | |
| parameterized.parameters | |
| Perm(0, 4, 5)(1, 3, 10) | |
| BL.transpose | |
| testui.configlist | |
| hp.quniform | |
| Special | |
| credentials.ReadOnlyCredentials | |
| X | |
| ctx.rectangle | |
| OrthographicConversion | |
| x_scale.reshape | |
| format_version | |
| myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime | |
| Permission.objects.get_by_natural_key | |
| machine_b.add_transition | |
| self.state.add_transition_list | |
| npr.rand | |
| pprint_Gamma_udd | |
| proxy.pause_and_divide | |
| ReverseProxyResource | |
| maint.text | |
| event.Event.bld | |
| np.linspace(-10, 10, 60).reshape | |
| instance.get_measurements | |
| sshclient.SSHClient | |
| self.A.endswith | |
| Perm(5) | |
| CoreFoundation.CFTimeZoneCreateWithName | |
| bde.ModelChangedEvent | |
| self.set_text_color | |
| self._instance_stub_internal.__exit__ |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment