prompt
stringlengths 1.74k
34.3k
| ref
stringlengths 4
432
|
|---|---|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: DLYuanGod/TinyGPT-V
# Path: minigpt4/common/registry.py
class Registry:
def register_builder(cls, name):
def wrap(builder_cls):
def register_task(cls, name):
def wrap(task_cls):
def register_model(cls, name):
def wrap(model_cls):
def register_processor(cls, name):
def wrap(processor_cls):
def register_lr_scheduler(cls, name):
def wrap(lr_sched_cls):
def register_runner(cls, name):
def wrap(runner_cls):
def register_path(cls, name, path):
def register(cls, name, obj):
def get_builder_class(cls, name):
def get_model_class(cls, name):
def get_task_class(cls, name):
def get_processor_class(cls, name):
def get_lr_scheduler_class(cls, name):
def get_runner_class(cls, name):
def list_runners(cls):
def list_models(cls):
def list_tasks(cls):
def list_processors(cls):
def list_lr_schedulers(cls):
def list_datasets(cls):
def get_path(cls, name):
def get(cls, name, default=None, no_warning=False):
def unregister(cls, name):
# Path: minigpt4/processors/base_processor.py
class BaseProcessor:
def __init__(self):
self.transform = lambda x: x
return
def __call__(self, item):
return self.transform(item)
@classmethod
def from_config(cls, cfg=None):
return cls()
def build(self, **kwargs):
cfg = OmegaConf.create(kwargs)
return self.from_config(cfg)
# Path: minigpt4/processors/randaugment.py
class RandomAugment(object):
def __init__(self, N=2, M=10, isPIL=False, augs=[]):
self.N = N
self.M = M
self.isPIL = isPIL
if augs:
self.augs = augs
else:
self.augs = list(arg_dict.keys())
def get_random_ops(self):
sampled_ops = np.random.choice(self.augs, self.N)
return [(op, 0.5, self.M) for op in sampled_ops]
def __call__(self, img):
if self.isPIL:
img = np.array(img)
ops = self.get_random_ops()
for name, prob, level in ops:
if np.random.random() > prob:
continue
args = arg_dict[name](level)
img = func_dict[name](img, *args)
return img
# Path: minigpt4/processors/blip_processors.py
import re
from minigpt4.common.registry import registry
from minigpt4.processors.base_processor import BaseProcessor
from minigpt4.processors.randaugment import RandomAugment
from omegaconf import OmegaConf
from torchvision import transforms
from torchvision.transforms.functional import InterpolationMode
"""
Copyright (c) 2022, salesforce.com, inc.
All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
For full license text, see the LICENSE_Lavis file in the repo root or https://opensource.org/licenses/BSD-3-Clause
"""
| class BlipImageBaseProcessor(BaseProcessor): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: jianchang512/vocal-separate
# Path: vocal/cfg.py
LANG = "en" if locale.getdefaultlocale()[0].split('_')[0].lower() != 'zh' else "zh"
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, 'pretrained_models')
STATIC_DIR = os.path.join(ROOT_DIR, 'static')
TMP_DIR = os.path.join(STATIC_DIR, 'tmp')
FILES_DIR = os.path.join(STATIC_DIR, 'files')
# Path: vocal/tool.py
def runffmpeg(arg):
def checkupdate():
def openweb(web_address):
# Path: vocal/cfg.py
ROOT_DIR = os.getcwd()
# Path: start.py
import logging
import threading
import sys
import os
import subprocess
from flask import Flask, request, render_template, jsonify, send_from_directory
from gevent.pywsgi import WSGIServer, WSGIHandler,LoggingLogAdapter
from logging.handlers import RotatingFileHandler
from vocal import cfg, tool
from vocal.cfg import ROOT_DIR
from spleeter.separator import Separator
class CustomRequestHandler(WSGIHandler):
def log_request(self):
pass
# 禁用 Werkzeug 默认的日志处理器
log = logging.getLogger('werkzeug')
log.handlers[:] = []
log.setLevel(logging.WARNING)
app = Flask(__name__, static_folder=os.path.join(ROOT_DIR, 'static'), static_url_path='/static',
template_folder=os.path.join(ROOT_DIR, 'templates'))
root_log = logging.getLogger() # Flask的根日志记录器
root_log.handlers = []
root_log.setLevel(logging.WARNING)
# 配置日志
app.logger.setLevel(logging.WARNING) # 设置日志级别为 INFO
# 创建 RotatingFileHandler 对象，设置写入的文件路径和大小限制
file_handler = RotatingFileHandler(os.path.join(ROOT_DIR, 'vocal.log'), maxBytes=1024 * 1024, backupCount=5)
# 创建日志的格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 设置文件处理器的级别和格式
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
# 将文件处理器添加到日志记录器中
app.logger.addHandler(file_handler)
@app.route('/static/<path:filename>')
def static_files(filename):
return send_from_directory(app.config['STATIC_FOLDER'], filename)
@app.route('/')
def index():
return render_template("index.html",cuda=cfg.cuda, language=cfg.LANG,root_dir=ROOT_DIR.replace('\\', '/'))
# 上传音频
@app.route('/upload', methods=['POST'])
def upload():
try:
# 获取上传的文件
audio_file = request.files['audio']
# 如果是mp4
noextname, ext = os.path.splitext(audio_file.filename)
ext = ext.lower()
# 如果是视频，先分离
wav_file = os.path.join(cfg.TMP_DIR, f'{noextname}.wav')
if os.path.exists(wav_file) and os.path.getsize(wav_file) > 0:
return jsonify({'code': 0, 'msg': cfg.transobj['lang1'], "data": os.path.basename(wav_file)})
msg=""
if ext in ['.mp4', '.mov', '.avi', '.mkv', '.mpeg', '.mp3', '.flac']:
video_file = os.path.join(cfg.TMP_DIR, f'{noextname}{ext}')
audio_file.save(video_file)
params = [
"-i",
video_file,
]
if ext not in ['.mp3', '.flac']:
params.append('-vn')
params.append(wav_file)
| rs = tool.runffmpeg(params) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ali-vilab/dreamtalk
# Path: core/networks/transformer.py
def _get_activation_fn(activation):
"""Return an activation function given a string"""
if activation == "relu":
return F.relu
if activation == "gelu":
return F.gelu
if activation == "glu":
return F.glu
raise RuntimeError(F"activation should be relu/gelu, not {activation}.")
# Path: core/networks/transformer.py
def _get_clones(module, N):
return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
# Path: core/networks/dynamic_linear.py
class DynamicLinear(nn.Module):
def __init__(self, in_planes, out_planes, cond_planes, bias=True, K=4, temperature=30, ratio=4, init_weight=True):
super().__init__()
self.dynamic_conv = DynamicConv(
in_planes,
out_planes,
cond_planes,
kernel_size=1,
stride=1,
padding=0,
bias=bias,
K=K,
ratio=ratio,
temperature=temperature,
init_weight=init_weight,
)
def forward(self, x, cond):
"""
Args:
x (_type_): (L, B, C_in)
cond (_type_): (B, C_style)
Returns:
_type_: (L, B, C_out)
"""
x = x.permute(1, 2, 0).unsqueeze(-1)
out = self.dynamic_conv(x, cond)
# (B, C_out, L, 1)
out = out.squeeze().permute(2, 0, 1)
return out
# Path: core/networks/dynamic_fc_decoder.py
import torch.nn as nn
import torch
from core.networks.transformer import _get_activation_fn, _get_clones
from core.networks.dynamic_linear import DynamicLinear
class DynamicFCDecoderLayer(nn.Module):
def __init__(
self,
d_model,
nhead,
d_style,
dynamic_K,
dynamic_ratio,
dim_feedforward=2048,
dropout=0.1,
activation="relu",
normalize_before=False,
):
super().__init__()
self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
# Implementation of Feedforward model
# self.linear1 = nn.Linear(d_model, dim_feedforward)
self.linear1 = DynamicLinear(d_model, dim_feedforward, d_style, K=dynamic_K, ratio=dynamic_ratio)
self.dropout = nn.Dropout(dropout)
self.linear2 = nn.Linear(dim_feedforward, d_model)
# self.linear2 = DynamicLinear(dim_feedforward, d_model, d_style, K=dynamic_K, ratio=dynamic_ratio)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.norm3 = nn.LayerNorm(d_model)
self.dropout1 = nn.Dropout(dropout)
self.dropout2 = nn.Dropout(dropout)
self.dropout3 = nn.Dropout(dropout)
self.activation = _get_activation_fn(activation)
self.normalize_before = normalize_before
def with_pos_embed(self, tensor, pos):
return tensor if pos is None else tensor + pos
def forward_post(
self,
tgt,
memory,
style,
tgt_mask=None,
memory_mask=None,
tgt_key_padding_mask=None,
memory_key_padding_mask=None,
pos=None,
query_pos=None,
):
# q = k = self.with_pos_embed(tgt, query_pos)
tgt2 = self.self_attn(tgt, tgt, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
tgt = tgt + self.dropout1(tgt2)
tgt = self.norm1(tgt)
tgt2 = self.multihead_attn(
query=tgt, key=memory, value=memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask
)[0]
tgt = tgt + self.dropout2(tgt2)
tgt = self.norm2(tgt)
# tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt, style))), style)
tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt, style))))
tgt = tgt + self.dropout3(tgt2)
tgt = self.norm3(tgt)
return tgt
# def forward_pre(
# self,
# tgt,
# memory,
# tgt_mask=None,
# memory_mask=None,
# tgt_key_padding_mask=None,
# memory_key_padding_mask=None,
# pos=None,
# query_pos=None,
# ):
# tgt2 = self.norm1(tgt)
# # q = k = self.with_pos_embed(tgt2, query_pos)
# tgt2 = self.self_attn(tgt2, tgt2, value=tgt2, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask)[0]
# tgt = tgt + self.dropout1(tgt2)
# tgt2 = self.norm2(tgt)
# tgt2 = self.multihead_attn(
# query=tgt2, key=memory, value=memory, attn_mask=memory_mask, key_padding_mask=memory_key_padding_mask
# )[0]
# tgt = tgt + self.dropout2(tgt2)
# tgt2 = self.norm3(tgt)
# tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
# tgt = tgt + self.dropout3(tgt2)
# return tgt
def forward(
self,
tgt,
memory,
style,
tgt_mask=None,
memory_mask=None,
tgt_key_padding_mask=None,
memory_key_padding_mask=None,
pos=None,
query_pos=None,
):
if self.normalize_before:
raise NotImplementedError
# return self.forward_pre(
# tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos
# )
return self.forward_post(
tgt, memory, style, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask, pos, query_pos
)
class DynamicFCDecoder(nn.Module):
def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
super().__init__()
| self.layers = _get_clones(decoder_layer, num_layers) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: jiawei-ren/dreamgaussian4d
# Path: diffusers/src/diffusers/utils/constants.py
USE_PEFT_BACKEND = _required_peft_version and _required_transformers_version
# Path: diffusers/src/diffusers/models/lora.py
class LoRACompatibleLinear(nn.Linear):
"""
A Linear layer that can be used with LoRA.
"""
def __init__(self, *args, lora_layer: Optional[LoRALinearLayer] = None, **kwargs):
super().__init__(*args, **kwargs)
self.lora_layer = lora_layer
def set_lora_layer(self, lora_layer: Optional[LoRALinearLayer]):
self.lora_layer = lora_layer
def _fuse_lora(self, lora_scale: float = 1.0, safe_fusing: bool = False):
if self.lora_layer is None:
return
dtype, device = self.weight.data.dtype, self.weight.data.device
w_orig = self.weight.data.float()
w_up = self.lora_layer.up.weight.data.float()
w_down = self.lora_layer.down.weight.data.float()
if self.lora_layer.network_alpha is not None:
w_up = w_up * self.lora_layer.network_alpha / self.lora_layer.rank
fused_weight = w_orig + (lora_scale * torch.bmm(w_up[None, :], w_down[None, :])[0])
if safe_fusing and torch.isnan(fused_weight).any().item():
raise ValueError(
"This LoRA weight seems to be broken. "
f"Encountered NaN values when trying to fuse LoRA weights for {self}."
"LoRA weights will not be fused."
)
self.weight.data = fused_weight.to(device=device, dtype=dtype)
# we can drop the lora layer now
self.lora_layer = None
# offload the up and down matrices to CPU to not blow the memory
self.w_up = w_up.cpu()
self.w_down = w_down.cpu()
self._lora_scale = lora_scale
def _unfuse_lora(self):
if not (getattr(self, "w_up", None) is not None and getattr(self, "w_down", None) is not None):
return
fused_weight = self.weight.data
dtype, device = fused_weight.dtype, fused_weight.device
w_up = self.w_up.to(device=device).float()
w_down = self.w_down.to(device).float()
unfused_weight = fused_weight.float() - (self._lora_scale * torch.bmm(w_up[None, :], w_down[None, :])[0])
self.weight.data = unfused_weight.to(device=device, dtype=dtype)
self.w_up = None
self.w_down = None
def forward(self, hidden_states: torch.Tensor, scale: float = 1.0) -> torch.Tensor:
if self.lora_layer is None:
out = super().forward(hidden_states)
return out
else:
out = super().forward(hidden_states) + (scale * self.lora_layer(hidden_states))
return out
# Path: diffusers/src/diffusers/models/activations.py
import torch
import torch.nn.functional as F
from torch import nn
from ..utils import USE_PEFT_BACKEND
from .lora import LoRACompatibleLinear
# coding=utf-8
# Copyright 2023 HuggingFace Inc.
#
# 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 writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
ACTIVATION_FUNCTIONS = {
"swish": nn.SiLU(),
"silu": nn.SiLU(),
"mish": nn.Mish(),
"gelu": nn.GELU(),
"relu": nn.ReLU(),
}
def get_activation(act_fn: str) -> nn.Module:
"""Helper function to get activation function from string.
Args:
act_fn (str): Name of activation function.
Returns:
nn.Module: Activation function.
"""
act_fn = act_fn.lower()
if act_fn in ACTIVATION_FUNCTIONS:
return ACTIVATION_FUNCTIONS[act_fn]
else:
raise ValueError(f"Unsupported activation function: {act_fn}")
class GELU(nn.Module):
r"""
GELU activation function with tanh approximation support with `approximate="tanh"`.
Parameters:
dim_in (`int`): The number of channels in the input.
dim_out (`int`): The number of channels in the output.
approximate (`str`, *optional*, defaults to `"none"`): If `"tanh"`, use tanh approximation.
"""
def __init__(self, dim_in: int, dim_out: int, approximate: str = "none"):
super().__init__()
self.proj = nn.Linear(dim_in, dim_out)
self.approximate = approximate
def gelu(self, gate: torch.Tensor) -> torch.Tensor:
if gate.device.type != "mps":
return F.gelu(gate, approximate=self.approximate)
# mps: gelu is not implemented for float16
return F.gelu(gate.to(dtype=torch.float32), approximate=self.approximate).to(dtype=gate.dtype)
def forward(self, hidden_states):
hidden_states = self.proj(hidden_states)
hidden_states = self.gelu(hidden_states)
return hidden_states
class GEGLU(nn.Module):
r"""
A [variant](https://arxiv.org/abs/2002.05202) of the gated linear unit activation function.
Parameters:
dim_in (`int`): The number of channels in the input.
dim_out (`int`): The number of channels in the output.
"""
def __init__(self, dim_in: int, dim_out: int):
super().__init__()
| linear_cls = LoRACompatibleLinear if not USE_PEFT_BACKEND else nn.Linear |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Meituan-AutoML/MobileVLM
# Path: mobilevlm/model/vision_encoder.py
def build_vision_tower(model_cfg, **kwargs):
vision_tower = getattr(model_cfg, 'mm_vision_tower', getattr(model_cfg, 'vision_tower', None))
is_absolute_path_exists = os.path.exists(vision_tower)
if is_absolute_path_exists or vision_tower.startswith("openai") or vision_tower.startswith("laion"):
vision_tower_type = getattr(model_cfg, 'vision_tower_type', None)
if vision_tower_type == "clip":
return CLIPVisionTower(vision_tower, args=model_cfg, **kwargs)
raise ValueError(f'Unknown vision tower: {vision_tower}')
# Path: mobilevlm/model/vision_projector.py
def build_vision_projector(config, delay_load=False, **kwargs):
projector_type = getattr(config, 'mm_projector_type', 'linear')
if projector_type == 'linear':
return nn.Linear(config.mm_hidden_size, config.hidden_size)
elif projector_type.startswith('mlp'):
mlp_gelu_match = re.match(r'^mlp(\d+)x_gelu$', projector_type)
if mlp_gelu_match:
mlp_depth = int(mlp_gelu_match.group(1))
modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
for _ in range(1, mlp_depth):
modules.append(nn.GELU())
modules.append(nn.Linear(config.hidden_size, config.hidden_size))
return nn.Sequential(*modules)
elif projector_type.startswith('ldpnet'):
return LDPNetProjector(config)
raise ValueError(f'Unknown projector type: {projector_type}')
# Path: mobilevlm/constants.py
IGNORE_INDEX = -100
# Path: mobilevlm/constants.py
IMAGE_TOKEN_INDEX = -200
# Path: mobilevlm/constants.py
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
# Path: mobilevlm/constants.py
DEFAULT_IM_START_TOKEN = "<im_start>"
# Path: mobilevlm/constants.py
DEFAULT_IM_END_TOKEN = "<im_end>"
# Path: mobilevlm/model/mobilevlm.py
import torch
import torch.nn as nn
from abc import ABC, abstractmethod
from transformers import AutoTokenizer, BitsAndBytesConfig
from mobilevlm.model.vision_encoder import build_vision_tower
from mobilevlm.model.vision_projector import build_vision_projector
from mobilevlm.constants import IGNORE_INDEX, IMAGE_TOKEN_INDEX, \
DEFAULT_IMAGE_PATCH_TOKEN, DEFAULT_IM_START_TOKEN, DEFAULT_IM_END_TOKEN
from mobilevlm.model.mobilellama import MobileLlamaForCausalLM
class MobileVLMMetaModel:
def __init__(self, config):
super(MobileVLMMetaModel, self).__init__(config)
if hasattr(config, "mm_vision_tower"):
self.vision_tower = build_vision_tower(config, delay_load=False)
self.mm_projector = build_vision_projector(config)
def get_vision_tower(self):
vision_tower = getattr(self, 'vision_tower', None)
if type(vision_tower) is list:
vision_tower = vision_tower[0]
return vision_tower
def initialize_vision_modules(self, model_args, fsdp=None):
mm_vision_select_layer = model_args.mm_vision_select_layer
mm_vision_select_feature = model_args.mm_vision_select_feature
pretrain_mm_mlp_adapter = model_args.pretrain_mm_mlp_adapter
self.config.mm_vision_tower = model_args.vision_tower
self.config.use_mm_proj = True
self.config.mm_projector_type = getattr(model_args, 'mm_projector_type', 'linear')
self.config.mm_vision_select_layer = mm_vision_select_layer
self.config.mm_vision_select_feature = mm_vision_select_feature
# Build VisionTower
vision_tower = build_vision_tower(model_args)
if fsdp is not None and len(fsdp) > 0:
self.vision_tower = [vision_tower]
else:
self.vision_tower = vision_tower
self.config.mm_hidden_size = vision_tower.hidden_size
# Build Vision-Projector
self.mm_projector = build_vision_projector(self.config)
if pretrain_mm_mlp_adapter is not None:
mm_projector_weights = torch.load(pretrain_mm_mlp_adapter, map_location='cpu')
def get_w(weights, keyword):
return {k.split(keyword + '.')[1]: v for k, v in weights.items() if keyword in k}
self.mm_projector.load_state_dict(get_w(mm_projector_weights, 'mm_projector'))
class MobileVLMMetaForCausalLM(ABC):
@abstractmethod
def get_model(self):
pass
def get_vision_tower(self):
return self.get_model().get_vision_tower()
def encode_images(self, images):
image_features = self.get_model().get_vision_tower()(images)
image_features = self.get_model().mm_projector(image_features)
return image_features
def prepare_inputs_labels_for_multimodal(
self, input_ids, attention_mask, past_key_values, labels, images
):
vision_tower = self.get_vision_tower()
if vision_tower is None or images is None or input_ids.shape[1] == 1:
if past_key_values is not None and vision_tower is not None and images is not None and input_ids.shape[1] == 1:
attention_mask = torch.ones((attention_mask.shape[0], past_key_values[-1][-1].shape[-2] + 1), dtype=attention_mask.dtype, device=attention_mask.device)
return input_ids, attention_mask, past_key_values, None, labels
if type(images) is list or images.ndim == 5:
concat_images = torch.cat([image for image in images], dim=0)
image_features = self.encode_images(concat_images)
split_sizes = [image.shape[0] for image in images]
image_features = torch.split(image_features, split_sizes, dim=0)
image_features = [x.flatten(0, 1) for x in image_features]
else:
image_features = self.encode_images(images)
new_input_embeds = []
new_labels = [] if labels is not None else None
cur_image_idx = 0
for batch_idx, cur_input_ids in enumerate(input_ids):
| if (cur_input_ids == IMAGE_TOKEN_INDEX).sum() == 0: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: kinggongzilla/ai-clone-whatsapp
# Path: configs/datasets.py
class custom_dataset:
# Path: configs/peft.py
class lora_config:
r: int=8
lora_alpha: int=32
target_modules: List[str] = field(default_factory=lambda: ["q_proj", "v_proj"])
bias= "none"
task_type: str= "CAUSAL_LM"
lora_dropout: float=0.05
inference_mode: bool = False
# Path: configs/peft.py
class llama_adapter_config:
adapter_len: int= 10
adapter_layers: int= 30
task_type: str= "CAUSAL_LM"
# Path: configs/peft.py
class prefix_config:
num_virtual_tokens: int=30
task_type: str= "CAUSAL_LM"
# Path: configs/training.py
class train_config:
whatsapp_username: str="" # your own whatsapp user name as it is in the chat .txt files
model_name: str="mistralai/Mistral-7B-Instruct-v0.2"
enable_fsdp: bool=False
low_cpu_fsdp: bool=False
run_validation: bool=False
batch_size_training: int=1
batching_strategy: str="packing" #alternative: padding
context_length: int=4096
gradient_accumulation_steps: int=1
gradient_clipping: bool = False
gradient_clipping_threshold: float = 1.0
num_epochs: int=1
num_workers_dataloader: int=1
lr: float=1e-4
weight_decay: float=0.0
gamma: float= 0.85
seed: int=42
use_fp16: bool=True
mixed_precision: bool=True
val_batch_size: int=1
dataset = "custom_dataset"
data_dir: str = "data/preprocessing/processed_chats"
peft_method: str = "lora" # None , llama_adapter, prefix
use_peft: bool=True
output_dir: str = "checkpoints"
freeze_layers: bool = False
num_freeze_layers: int = 1
quantization: bool = True
one_gpu: bool = False
save_model: bool = True
dist_checkpoint_root_folder: str="PATH/to/save/FSDP/model" # will be used if using FSDP
dist_checkpoint_folder: str="fine-tuned" # will be used if using FSDP
save_optimizer: bool=False # will be used if using FSDP
use_fast_kernels: bool = False # Enable using SDPA from PyTroch Accelerated Transformers, make use Flash Attention and Xformer memory-efficient kernels
# Path: data/sampler.py
class LengthBasedBatchSampler(torch.utils.data.BatchSampler):
def __init__(self, data_source, batch_size: int, drop_last: bool, shuffle: bool=True) -> None:
if isinstance(next(iter(data_source)), dict):
first_key = next(iter(next(iter(data_source)).keys()))
self.lengths = [len(d[first_key]) for d in data_source]
else:
self.lengths = [len(d) for d in data_source]
self.batch_size = batch_size
self.drop_last = drop_last
self.shuffle = shuffle
def __iter__(self):
ids = np.argsort(self.lengths)
if self.drop_last:
ids = ids[:len(ids) // self.batch_size * self.batch_size]
batches = [ids[i:i+self.batch_size] for i in range(0, len(ids), self.batch_size)]
if self.shuffle:
random.shuffle(batches)
for b in batches:
yield b
def __len__(self):
if self.drop_last:
return len(self.lengths) // self.batch_size
else:
return len(self.lengths) // self.batch_size + (len(self.lengths) % self.batch_size > 0)
# Path: data/sampler.py
class DistributedLengthBasedBatchSampler(torch.utils.data.BatchSampler):
def __init__(self, data_source, batch_size: int, num_replicas: int, rank: int, shuffle: bool = True, seed: int = 0) -> None:
random.seed(seed)
self.batch_sampler = LengthBasedBatchSampler(
data_source, batch_size=batch_size, drop_last=True, shuffle=shuffle
)
self.num_replicas = num_replicas
self.rank = rank
def __iter__(self):
max_length = len(self.batch_sampler) // self.num_replicas * self.num_replicas
return islice(self.batch_sampler, self.rank, max_length, self.num_replicas)
def __len__(self):
return len(self.batch_sampler) // self.num_replicas
# Path: utils/dataset_utils.py
DATASET_PREPROC = {
"custom_dataset": get_custom_dataset,
}
# Path: utils/config_utils.py
import inspect
import torch.distributed as dist
from dataclasses import asdict
from torch.utils.data import DistributedSampler
from peft import (
LoraConfig,
AdaptionPromptConfig,
PrefixTuningConfig,
)
from transformers import default_data_collator
from transformers.data import DataCollatorForSeq2Seq
from configs import datasets, lora_config, llama_adapter_config, prefix_config, train_config
from data.sampler import LengthBasedBatchSampler, DistributedLengthBasedBatchSampler
from utils.dataset_utils import DATASET_PREPROC
# Copyright (c) Meta Platforms, Inc. and affiliates.
# This software may be used and distributed according to the terms of the Llama 2 Community License Agreement.
def update_config(config, **kwargs):
if isinstance(config, (tuple, list)):
for c in config:
update_config(c, **kwargs)
else:
for k, v in kwargs.items():
if hasattr(config, k):
setattr(config, k, v)
elif "." in k:
# allow --some_config.some_param=True
config_name, param_name = k.split(".")
if type(config).__name__ == config_name:
if hasattr(config, param_name):
setattr(config, param_name, v)
else:
# In case of specialized config we can warm user
print(f"Warning: {config_name} does not accept parameter: {k}")
elif isinstance(config, train_config):
print(f"Warning: unknown parameter {k}")
def generate_peft_config(train_config, kwargs):
| configs = (lora_config, llama_adapter_config, prefix_config) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: FoundationVision/UniRef
# Path: projects/UniRef/uniref/util/box_ops.py
def box_cxcywh_to_xyxy(x):
# print('box:\n', x)
x_c, y_c, w, h = x.unbind(-1)
b = [(x_c - 0.5 * w), (y_c - 0.5 * h),
(x_c + 0.5 * w), (y_c + 0.5 * h)]
return torch.stack(b, dim=-1)
# Path: projects/UniRef/uniref/util/box_ops.py
def generalized_box_iou(boxes1, boxes2):
"""
Generalized IoU from https://giou.stanford.edu/
The boxes should be in [x0, y0, x1, y1] format
Returns a [N, M] pairwise matrix, where N = len(boxes1)
and M = len(boxes2)
"""
# degenerate boxes gives inf / nan results
# so do an early check
assert (boxes1[:, 2:] >= boxes1[:, :2]).all()
assert (boxes2[:, 2:] >= boxes2[:, :2]).all()
iou, union = box_iou(boxes1, boxes2)
lt = torch.min(boxes1[:, None, :2], boxes2[:, :2])
rb = torch.max(boxes1[:, None, 2:], boxes2[:, 2:])
wh = (rb - lt).clamp(min=0) # [N,M,2]
area = wh[:, :, 0] * wh[:, :, 1]
return iou - (area - union) / (area+1e-7)
# Path: projects/UniRef/uniref/models/deformable_detr/matcher.py
import torch
import torch.nn.functional as F
import torchvision.ops as ops
from scipy.optimize import linear_sum_assignment
from torch import nn
from ...util.box_ops import box_cxcywh_to_xyxy, generalized_box_iou
# ------------------------------------------------------------------------
# Deformable DETR
# Copyright (c) 2020 SenseTime. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 [see LICENSE for details]
# ------------------------------------------------------------------------
# Modified from DETR (https://github.com/facebookresearch/detr)
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
# ------------------------------------------------------------------------
"""
Modules to compute the matching cost and solve the corresponding LSAP.
"""
class HungarianMatcher(nn.Module):
"""This class computes an assignment between the targets and the predictions of the network
For efficiency reasons, the targets don't include the no_object. Because of this, in general,
there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
while the others are un-matched (and thus treated as non-objects).
"""
def __init__(self,
cost_class: float = 1,
cost_bbox: float = 1,
cost_giou: float = 1):
"""Creates the matcher
Params:
cost_class: This is the relative weight of the classification error in the matching cost
cost_bbox: This is the relative weight of the L1 error of the bounding box coordinates in the matching cost
cost_giou: This is the relative weight of the giou loss of the bounding box in the matching cost
"""
super().__init__()
self.cost_class = cost_class
self.cost_bbox = cost_bbox
self.cost_giou = cost_giou
assert cost_class != 0 or cost_bbox != 0 or cost_giou != 0, "all costs cant be 0"
def forward_ota(self, outputs, targets):
""" simOTA for detr
"""
with torch.no_grad():
bs, num_queries = outputs["pred_logits"].shape[:2]
out_prob = outputs["pred_logits"].sigmoid()
out_bbox = outputs["pred_boxes"] # 跳过frame 维度
indices = []
matched_ids = []
for batch_idx in range(bs):
bz_boxes = out_bbox[batch_idx] #[300,4]
bz_out_prob = out_prob[batch_idx]
bz_tgt_ids = targets[batch_idx]["labels"]
num_insts = len(bz_tgt_ids)
bz_gtboxs = targets[batch_idx]['boxes'].reshape(num_insts,4) #[num_gt, 4]
fg_mask, is_in_boxes_and_center = \
self.get_in_boxes_info(bz_boxes,bz_gtboxs,expanded_strides=32)
pair_wise_ious = ops.box_iou(box_cxcywh_to_xyxy(bz_boxes), box_cxcywh_to_xyxy(bz_gtboxs))
# pair_wise_ious_loss = -torch.log(pair_wise_ious + 1e-8)
# Compute the classification cost.
alpha = 0.25
gamma = 2.0
neg_cost_class = (1 - alpha) * (bz_out_prob ** gamma) * (-(1 - bz_out_prob + 1e-8).log())
pos_cost_class = alpha * ((1 - bz_out_prob) ** gamma) * (-(bz_out_prob + 1e-8).log())
cost_class = pos_cost_class[:, bz_tgt_ids] - neg_cost_class[:, bz_tgt_ids]
| cost_giou = -generalized_box_iou(box_cxcywh_to_xyxy(bz_boxes), box_cxcywh_to_xyxy(bz_gtboxs)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: xhuangcv/humannorm
# Path: threestudio/models/materials/base.py
class BaseMaterial(BaseModule):
@dataclass
class Config(BaseModule.Config):
pass
cfg: Config
requires_normal: bool = False
requires_tangent: bool = False
def configure(self):
pass
def forward(self, *args, **kwargs) -> Float[Tensor, "*B 3"]:
raise NotImplementedError
def export(self, *args, **kwargs) -> Dict[str, Any]:
return {}
# Path: threestudio/models/networks.py
def get_encoding(n_input_dims: int, config) -> nn.Module:
# input suppose to be range [0, 1]
encoding: nn.Module
if config.otype == "ProgressiveBandFrequency":
encoding = ProgressiveBandFrequency(n_input_dims, config_to_primitive(config))
elif config.otype == "ProgressiveBandHashGrid":
encoding = ProgressiveBandHashGrid(n_input_dims, config_to_primitive(config))
else:
encoding = TCNNEncoding(n_input_dims, config_to_primitive(config))
encoding = CompositeEncoding(
encoding,
include_xyz=config.get("include_xyz", False),
xyz_scale=2.0,
xyz_offset=-1.0,
) # FIXME: hard coded
return encoding
# Path: threestudio/models/networks.py
def get_mlp(n_input_dims, n_output_dims, config) -> nn.Module:
network: nn.Module
if config.otype == "VanillaMLP":
network = VanillaMLP(n_input_dims, n_output_dims, config_to_primitive(config))
elif config.otype == "SphereInitVanillaMLP":
network = SphereInitVanillaMLP(
n_input_dims, n_output_dims, config_to_primitive(config)
)
else:
assert (
config.get("sphere_init", False) is False
), "sphere_init=True only supported by VanillaMLP"
network = TCNNNetwork(n_input_dims, n_output_dims, config_to_primitive(config))
return network
# Path: threestudio/utils/ops.py
def dot(x, y):
return torch.sum(x * y, -1, keepdim=True)
# Path: threestudio/utils/ops.py
def get_activation(name) -> Callable:
if name is None:
return lambda x: x
name = name.lower()
if name == "none":
return lambda x: x
elif name == "lin2srgb":
return lambda x: torch.where(
x > 0.0031308,
torch.pow(torch.clamp(x, min=0.0031308), 1.0 / 2.4) * 1.055 - 0.055,
12.92 * x,
).clamp(0.0, 1.0)
elif name == "exp":
return lambda x: torch.exp(x)
elif name == "shifted_exp":
return lambda x: torch.exp(x - 1.0)
elif name == "trunc_exp":
return trunc_exp
elif name == "shifted_trunc_exp":
return lambda x: trunc_exp(x - 1.0)
elif name == "sigmoid":
return lambda x: torch.sigmoid(x)
elif name == "tanh":
return lambda x: torch.tanh(x)
elif name == "shifted_softplus":
return lambda x: F.softplus(x - 1.0)
elif name == "scale_-11_01":
return lambda x: x * 0.5 + 0.5
else:
try:
return getattr(F, name)
except AttributeError:
raise ValueError(f"Unknown activation function: {name}")
# Path: threestudio/models/materials/neural_radiance_material.py
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
import threestudio
from dataclasses import dataclass, field
from threestudio.models.materials.base import BaseMaterial
from threestudio.models.networks import get_encoding, get_mlp
from threestudio.utils.ops import dot, get_activation
from threestudio.utils.typing import *
@threestudio.register("neural-radiance-material")
class NeuralRadianceMaterial(BaseMaterial):
@dataclass
class Config(BaseMaterial.Config):
input_feature_dims: int = 8
color_activation: str = "sigmoid"
dir_encoding_config: dict = field(
default_factory=lambda: {"otype": "SphericalHarmonics", "degree": 3}
)
mlp_network_config: dict = field(
default_factory=lambda: {
"otype": "FullyFusedMLP",
"activation": "ReLU",
"n_neurons": 16,
"n_hidden_layers": 2,
}
)
cfg: Config
def configure(self) -> None:
| self.encoding = get_encoding(3, self.cfg.dir_encoding_config) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: jianchang512/stt
# Path: stslib/cfg.py
LANG = "en" if locale.getdefaultlocale()[0].split('_')[0].lower() != 'zh' else "zh"
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, 'models')
STATIC_DIR = os.path.join(ROOT_DIR, 'static')
TMP_DIR = os.path.join(STATIC_DIR, 'tmp')
# Path: stslib/tool.py
def runffmpeg(arg):
def checkupdate():
def openweb(web_address):
def ms_to_time_string(*, ms=0, seconds=None):
# Path: stslib/cfg.py
ROOT_DIR = os.getcwd()
# Path: start.py
import logging
import re
import threading
import sys
import torch
import os
from flask import Flask, request, render_template, jsonify, send_from_directory
from gevent.pywsgi import WSGIServer, WSGIHandler, LoggingLogAdapter
from logging.handlers import RotatingFileHandler
from stslib import cfg, tool
from stslib.cfg import ROOT_DIR
from faster_whisper import WhisperModel
device = "cuda" if torch.cuda.is_available() else "cpu"
class CustomRequestHandler(WSGIHandler):
def log_request(self):
pass
# 配置日志
# 禁用 Werkzeug 默认的日志处理器
log = logging.getLogger('werkzeug')
log.handlers[:] = []
log.setLevel(logging.WARNING)
app = Flask(__name__, static_folder=os.path.join(ROOT_DIR, 'static'), static_url_path='/static',
template_folder=os.path.join(ROOT_DIR, 'templates'))
root_log = logging.getLogger() # Flask的根日志记录器
root_log.handlers = []
root_log.setLevel(logging.WARNING)
# 配置日志
app.logger.setLevel(logging.WARNING) # 设置日志级别为 INFO
# 创建 RotatingFileHandler 对象，设置写入的文件路径和大小限制
file_handler = RotatingFileHandler(os.path.join(ROOT_DIR, 'sts.log'), maxBytes=1024 * 1024, backupCount=5)
# 创建日志的格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# 设置文件处理器的级别和格式
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(formatter)
# 将文件处理器添加到日志记录器中
app.logger.addHandler(file_handler)
@app.route('/static/<path:filename>')
def static_files(filename):
return send_from_directory(app.config['STATIC_FOLDER'], filename)
@app.route('/')
def index():
return render_template("index.html",
cuda=cfg.cuda,
lang_code=cfg.lang_code,
language=cfg.LANG,
root_dir=ROOT_DIR.replace('\\', '/'))
# 上传音频
@app.route('/upload', methods=['POST'])
def upload():
try:
# 获取上传的文件
audio_file = request.files['audio']
# 如果是mp4
noextname, ext = os.path.splitext(audio_file.filename)
ext = ext.lower()
# 如果是视频，先分离
wav_file = os.path.join(cfg.TMP_DIR, f'{noextname}.wav')
if os.path.exists(wav_file) and os.path.getsize(wav_file) > 0:
return jsonify({'code': 0, 'msg': cfg.transobj['lang1'], "data": os.path.basename(wav_file)})
msg = ""
if ext in ['.mp4', '.mov', '.avi', '.mkv', '.mpeg', '.mp3', '.flac']:
video_file = os.path.join(cfg.TMP_DIR, f'{noextname}{ext}')
audio_file.save(video_file)
params = [
"-i",
video_file,
]
if ext not in ['.mp3', '.flac']:
params.append('-vn')
params.append(wav_file)
| rs = tool.runffmpeg(params) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: jesenzhang/ComfyUI_StreamDiffusion
# Path: streamdiffusion/image_filter.py
class SimilarImageFilter:
def __init__(self, threshold: float = 0.98, max_skip_frame: float = 10) -> None:
self.threshold = threshold
self.prev_tensor = None
self.cos = torch.nn.CosineSimilarity(dim=0, eps=1e-6)
self.max_skip_frame = max_skip_frame
self.skip_count = 0
def __call__(self, x: torch.Tensor) -> Optional[torch.Tensor]:
if self.prev_tensor is None:
self.prev_tensor = x.detach().clone()
return x
else:
cos_sim = self.cos(self.prev_tensor.reshape(-1), x.reshape(-1)).item()
sample = random.uniform(0, 1)
if self.threshold >= 1:
skip_prob = 0
else:
skip_prob = max(0, 1 - (1 - cos_sim) / (1 - self.threshold))
# not skip frame
if skip_prob < sample:
self.prev_tensor = x.detach().clone()
return x
# skip frame
else:
if self.skip_count > self.max_skip_frame:
self.skip_count = 0
self.prev_tensor = x.detach().clone()
return x
else:
self.skip_count += 1
return None
def set_threshold(self, threshold: float) -> None:
self.threshold = threshold
def set_max_skip_frame(self, max_skip_frame: float) -> None:
self.max_skip_frame = max_skip_frame
# Path: streamdiffusion/image_utils.py
def postprocess_image(
image: torch.Tensor,
output_type: str = "pil",
do_denormalize: Optional[List[bool]] = None,
) -> Union[torch.Tensor, np.ndarray, PIL.Image.Image]:
if not isinstance(image, torch.Tensor):
raise ValueError(
f"Input for postprocessing is in incorrect format: {type(image)}. We only support pytorch tensor"
)
if output_type == "latent":
return image
do_normalize_flg = True
if do_denormalize is None:
do_denormalize = [do_normalize_flg] * image.shape[0]
image = torch.stack(
[
denormalize(image[i]) if do_denormalize[i] else image[i]
for i in range(image.shape[0])
]
)
if output_type == "pt":
return image
image = pt_to_numpy(image)
if output_type == "np":
return image
if output_type == "pil":
return numpy_to_pil(image)
# Path: streamdiffusion/pipeline.py
import time
import numpy as np
import PIL.Image
import torch
from typing import List, Optional, Union, Any, Dict, Tuple, Literal
from diffusers import LCMScheduler, StableDiffusionPipeline
from diffusers.image_processor import VaeImageProcessor
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img import (
retrieve_latents,
)
from .image_filter import SimilarImageFilter
from .image_utils import postprocess_image
class StreamDiffusion:
def __init__(
self,
pipe: StableDiffusionPipeline,
t_index_list: List[int],
torch_dtype: torch.dtype = torch.float16,
width: int = 512,
height: int = 512,
do_add_noise: bool = True,
use_denoising_batch: bool = True,
frame_buffer_size: int = 1,
cfg_type: Literal["none", "full", "self", "initialize"] = "self",
) -> None:
self.device = pipe.device
self.dtype = torch_dtype
self.generator = None
self.height = height
self.width = width
self.latent_height = int(height // pipe.vae_scale_factor)
self.latent_width = int(width // pipe.vae_scale_factor)
self.frame_bff_size = frame_buffer_size
self.denoising_steps_num = len(t_index_list)
self.cfg_type = cfg_type
if use_denoising_batch:
self.batch_size = self.denoising_steps_num * frame_buffer_size
if self.cfg_type == "initialize":
self.trt_unet_batch_size = (
self.denoising_steps_num + 1
) * self.frame_bff_size
elif self.cfg_type == "full":
self.trt_unet_batch_size = (
2 * self.denoising_steps_num * self.frame_bff_size
)
else:
self.trt_unet_batch_size = self.denoising_steps_num * frame_buffer_size
else:
self.trt_unet_batch_size = self.frame_bff_size
self.batch_size = frame_buffer_size
self.t_list = t_index_list
self.do_add_noise = do_add_noise
self.use_denoising_batch = use_denoising_batch
self.similar_image_filter = False
| self.similar_filter = SimilarImageFilter() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: neobundy/MLX-Stable-Diffusion-WebUI
# Path: stable_diffusion/config.py
class DiffuserModelPathConfig:
class BaseConfig:
class AutoencoderConfig(BaseConfig):
class CLIPTextModelConfig(BaseConfig):
class UNetConfig(BaseConfig):
class DiffusionConfig(BaseConfig):
def __init__(self, model_path: str = "./diffuser_models"):
def unet_config(self):
def unet(self):
def scheduler(self):
def text_encoder_config(self):
def text_encoder(self):
def vae_config(self):
def vae(self):
def diffusion_config(self):
def tokenizer_vocab(self):
def tokenizer_merges(self):
def __getitem__(self, key):
def __setitem__(self, key, value):
# Path: stable_diffusion/model_io.py
_DEBUG = False
def _debug_print(*args, **kwargs):
def _from_numpy(x):
def map_unet_weights(key, value):
def map_clip_text_encoder_weights(key, value):
def map_vae_weights(key, value):
def _flatten(params):
def _load_safetensor_weights(mapper, model, weight_file, float16: bool = False):
def _check_key(key: str, part: str):
def load_unet(key: str = _DEFAULT_MODEL, float16: bool = False):
def load_text_encoder(key: str = _DEFAULT_MODEL, float16: bool = False):
def load_autoencoder(key: str = _DEFAULT_MODEL, float16: bool = False):
def load_diffusion_config(key: str = _DEFAULT_MODEL):
def load_tokenizer(key: str = _DEFAULT_MODEL):
def load_unet_local(weights_path: str, config_path: str, float16: bool = False):
def load_text_encoder_local(weights_path: str, config_path: str, float16: bool = False):
def load_autoencoder_local(weights_path: str, config_path: str, float16: bool = False):
def load_diffusion_config_local(config_path:str):
def load_tokenizer_local(vocab_path: str, merges_path: str):
def load_diffuser_model(diffuser_model_path: str, float16: bool = False):
# Path: utils.py
def _state_dict(model):
"""Return the model's state_dict as a dictionary."""
state_dict = {}
for name, param in model.parameters().items():
state_dict[name] = param
return state_dict
# Path: utils.py
def get_state_dict_from_safetensor(checkpoint_path: str):
"""Return the state_dict from the checkpoint."""
state_dict = {}
with safetensor_open(checkpoint_path, framework="numpy") as f:
# Access the data in the file
for key in f.keys():
tensor = f.get_tensor(key)
state_dict[key] = tensor
return state_dict
# Path: model_inspector.py
from stable_diffusion.config import PathConfig
from stable_diffusion.model_io import preload_models_from_safetensor_weights
from utils import _state_dict
from utils import get_state_dict_from_safetensor
INSPECTION_FILE = "model_inspection.txt"
NUM_ITEMS = 100
MODEL_FILE = "./models/v2-1_512-ema-pruned.safetensors"
MODEL_FILE1 = "./unet/diffusion_pytorch_model_test.safetensors"
MODEL_FILE2 = "./unet/xxmix9realistic_v40.safetensors"
# Recreate the inspection file at every execution of the script
with open(INSPECTION_FILE, 'w') as f:
pass
def write_to_file(*args, **kwargs):
"""Write the text to the inspection file."""
# Convert the arguments to a string
message = ' '.join(map(str, args))
# Print the message to the console
print(message, **kwargs)
# Open the log file in append mode and write the message
with open(INSPECTION_FILE, 'a') as f:
f.write(message + '\n')
def inspect_model(path_config: PathConfig, keys_only=True):
"""Inspect the contents of the models."""
# Load the models using the provided config and weights paths
unet_model = load_unet_local(path_config.unet_config, MODEL_FILE)
text_encoder_model = load_text_encoder_local(MODEL_FILE)
autoencoder_model = load_autoencoder_local(MODEL_FILE)
diffusion_config = load_diffusion_config_local(path_config.diffusion_config)
tokenizer = load_tokenizer_local(path_config.tokenizer_vocab, path_config.tokenizer_merges)
# Convert the models' state_dict to a dictionary and iterate over it
for model_name, model in zip(["unet", "text_encoder", "autoencoder"], [unet_model, text_encoder_model, autoencoder_model]):
write_to_file("-" * 50)
write_to_file(f"Model: {model_name}")
write_to_file("-" * 50)
| for key, value in _state_dict(model).items(): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ffmemes/ff-backend
# Path: src/database.py
DATABASE_URL = str(settings.DATABASE_URL)
async def fetch_one(select_query: Select | Insert | Update) -> dict[str, Any] | None:
async def fetch_all(select_query: Select | Insert | Update) -> list[dict[str, Any]]:
async def execute(select_query: Insert | Update) -> CursorResult:
# Path: src/storage/parsers/schemas.py
class TgChannelPostParsingResult(CustomModel):
post_id: int
url: str
content: str | None = None # post text
media: list[dict] | None = None
views: int
date: datetime
mentions: list[str] | None = None # mentioned usernames
hashtags: list[str] | None = None
forwarded: dict | None = None
forwarded_url: str | None = None # url to forwarded post
link_preview: dict | None = None
out_links: list[str] | None = None
# Path: src/storage/parsers/schemas.py
class VkGroupPostParsingResult(CustomModel):
post_id: str
url: str
content: str | None = None # post text
media: list[str]
date: datetime
views: int
likes: int
reposts: int
comments: int
# Path: src/storage/constants.py
class MemeSourceType(str, Enum):
TELEGRAM = "telegram"
VK = "vk"
REDDIT = "reddit"
INSTAGRAM = "instagram"
TWITTER = "twitter"
TIKTOK = "tiktok"
USER_UPLOAD = "user upload"
# Path: src/storage/constants.py
class MemeSourceStatus(str, Enum):
IN_MODERATION = "in_moderation"
PARSING_ENABLED = "parsing_enabled"
PARSING_DISABLED = "parsing_disabled"
# Path: src/storage/constants.py
class MemeType(str, Enum):
IMAGE = "image"
ANIMATION = "animation"
VIDEO = "video"
# Path: src/storage/constants.py
class MemeStatus(str, Enum):
CREATED = "created"
OK = "ok"
DUPLICATE = "duplicate"
AD = "ad"
BROKEN_CONTENT_LINK = "broken_content_link"
# TODO: more statuses?
# IN_MODERATION = "in_moderation"
# Path: src/storage/constants.py
MEME_RAW_TELEGRAM_MEME_SOURCE_POST_UNIQUE_CONSTRAINT = "meme_raw_telegram_meme_source_id_post_id_key"
# Path: src/storage/constants.py
MEME_RAW_VK_MEME_SOURCE_POST_UNIQUE_CONSTRAINT = "meme_raw_vk_meme_source_id_post_id_key"
# Path: src/storage/service.py
from typing import Any
from datetime import datetime
from sqlalchemy import select, nulls_first, text
from sqlalchemy.dialects.postgresql import insert
from src.database import (
language,
meme,
meme_source,
meme_raw_telegram,
meme_raw_vk,
execute, fetch_one, fetch_all,
)
from src.storage.parsers.schemas import TgChannelPostParsingResult, VkGroupPostParsingResult
from src.storage.constants import (
MemeSourceType,
MemeSourceStatus,
MemeType,
MemeStatus,
MEME_RAW_TELEGRAM_MEME_SOURCE_POST_UNIQUE_CONSTRAINT,
MEME_RAW_VK_MEME_SOURCE_POST_UNIQUE_CONSTRAINT,
)
async def insert_parsed_posts_from_telegram(
meme_source_id: int,
telegram_posts: list[TgChannelPostParsingResult],
) -> None:
posts = [
post.model_dump() | {"meme_source_id": meme_source_id}
for post in telegram_posts
]
insert_statement = insert(meme_raw_telegram).values(posts)
insert_posts_query = insert_statement.on_conflict_do_update(
constraint=MEME_RAW_TELEGRAM_MEME_SOURCE_POST_UNIQUE_CONSTRAINT,
set_={
"media": insert_statement.excluded.media,
"views": insert_statement.excluded.views,
"updated_at": datetime.utcnow(),
},
)
await execute(insert_posts_query)
async def insert_parsed_posts_from_vk(
meme_source_id: int,
vk_posts: list[VkGroupPostParsingResult],
) -> None:
posts = [
post.model_dump() | {"meme_source_id": meme_source_id}
for post in vk_posts
]
insert_statement = insert(meme_raw_vk).values(posts)
insert_posts_query = insert_statement.on_conflict_do_update(
constraint=MEME_RAW_VK_MEME_SOURCE_POST_UNIQUE_CONSTRAINT,
set_={
"media": insert_statement.excluded.media,
"views": insert_statement.excluded.views,
"likes": insert_statement.excluded.likes,
"reposts": insert_statement.excluded.reposts,
"comments": insert_statement.excluded.comments,
"updated_at": datetime.utcnow(),
},
)
await execute(insert_posts_query)
async def get_telegram_sources_to_parse(limit=10) -> list[dict[str, Any]]:
select_query = (
select(meme_source)
| .where(meme_source.c.type == MemeSourceType.TELEGRAM) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Con6924/SPM
# Path: src/misc/clip_templates.py
# Path: src/engine/train_util.py
def encode_prompts(
tokenizer: CLIPTokenizer,
text_encoder: CLIPTokenizer,
prompts: list[str],
return_tokens: bool = False,
):
text_tokens = text_tokenize(tokenizer, prompts)
text_embeddings = text_encode(text_encoder, text_tokens)
if return_tokens:
return text_embeddings, torch.unique(text_tokens, dim=1)
return text_embeddings
# Path: src/configs/prompt.py
from typing import Literal, Optional, Union
from pathlib import Path
from pydantic import BaseModel, root_validator
from transformers import CLIPTextModel, CLIPTokenizer
from src.misc.clip_templates import imagenet_templates
from src.engine.train_util import encode_prompts
import yaml
import pandas as pd
import random
import torch
class PromptEmbedsXL:
text_embeds: torch.FloatTensor
pooled_embeds: torch.FloatTensor
def __init__(self, embeds) -> None:
self.text_embeds, self.pooled_embeds = embeds
PROMPT_EMBEDDING = Union[torch.FloatTensor, PromptEmbedsXL]
class PromptEmbedsCache:
prompts: dict[str, PROMPT_EMBEDDING] = {}
def __setitem__(self, __name: str, __value: PROMPT_EMBEDDING) -> None:
self.prompts[__name] = __value
def __getitem__(self, __name: str) -> Optional[PROMPT_EMBEDDING]:
if __name in self.prompts:
return self.prompts[__name]
else:
return None
class PromptSettings(BaseModel): # yaml
target: str
positive: str = None # if None, target will be used
unconditional: str = "" # default is ""
neutral: str = None # if None, unconditional will be used
action: ACTION_TYPES = "erase" # default is "erase"
guidance_scale: float = 1.0 # default is 1.0
resolution: int = 512 # default is 512
dynamic_resolution: bool = False # default is False
batch_size: int = 1 # default is 1
dynamic_crops: bool = False # default is False. only used when model is XL
use_template: bool = False # default is False
la_strength: float = 1000.0
sampling_batch_size: int = 4
seed: int = None
case_number: int = 0
@root_validator(pre=True)
def fill_prompts(cls, values):
keys = values.keys()
if "target" not in keys:
raise ValueError("target must be specified")
if "positive" not in keys:
values["positive"] = values["target"]
if "unconditional" not in keys:
values["unconditional"] = ""
if "neutral" not in keys:
values["neutral"] = values["unconditional"]
return values
class PromptEmbedsPair:
target: PROMPT_EMBEDDING # the concept that do not want to generate
positive: PROMPT_EMBEDDING # generate the concept
unconditional: PROMPT_EMBEDDING # uncondition (default should be empty)
neutral: PROMPT_EMBEDDING # base condition (default should be empty)
use_template: bool = False # use clip template or not
guidance_scale: float
resolution: int
dynamic_resolution: bool
batch_size: int
dynamic_crops: bool
loss_fn: torch.nn.Module
action: ACTION_TYPES
def __init__(
self,
loss_fn: torch.nn.Module,
target: PROMPT_EMBEDDING,
positive: PROMPT_EMBEDDING,
unconditional: PROMPT_EMBEDDING,
neutral: PROMPT_EMBEDDING,
settings: PromptSettings,
) -> None:
self.loss_fn = loss_fn
self.target = target
self.positive = positive
self.unconditional = unconditional
self.neutral = neutral
self.settings = settings
self.use_template = settings.use_template
self.guidance_scale = settings.guidance_scale
self.resolution = settings.resolution
self.dynamic_resolution = settings.dynamic_resolution
self.batch_size = settings.batch_size
self.dynamic_crops = settings.dynamic_crops
self.action = settings.action
self.la_strength = settings.la_strength
self.sampling_batch_size = settings.sampling_batch_size
def _prepare_embeddings(
self,
cache: PromptEmbedsCache,
tokenizer: CLIPTokenizer,
text_encoder: CLIPTextModel,
):
"""
Prepare embeddings for training. When use_template is True, the embeddings will be
format using a template, and then be processed by the model.
"""
if not self.use_template:
return
template = random.choice(imagenet_templates)
target_prompt = template.format(self.settings.target)
if cache[target_prompt]:
self.target = cache[target_prompt]
else:
| self.target = encode_prompts(tokenizer, text_encoder, [target_prompt]) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: dakpinaroglu/Frame2seq
# Path: frame2seq/utils/residue_constants.py
def load_stereo_chemical_props() -> Tuple[Mapping[str, List[Bond]],
def make_bond_key(atom1_name, atom2_name):
def sequence_to_onehot(
sequence: str,
mapping: Mapping[str, int],
) -> np.ndarray:
def _make_standard_atom_mask() -> np.ndarray:
def _make_rigid_transformation_4x4(ex, ey, translation):
AA_TO_ID = {
'A': 0,
'C': 1,
'D': 2,
'E': 3,
'F': 4,
'G': 5,
'H': 6,
'I': 7,
'K': 8,
'L': 9,
'M': 10,
'N': 11,
'P': 12,
'Q': 13,
'R': 14,
'S': 15,
'T': 16,
'V': 17,
'W': 18,
'Y': 19,
'X': 20,
}
ID_TO_AA = {
0: 'A',
1: 'C',
2: 'D',
3: 'E',
4: 'F',
5: 'G',
6: 'H',
7: 'I',
8: 'K',
9: 'L',
10: 'M',
11: 'N',
12: 'P',
13: 'Q',
14: 'R',
15: 'S',
16: 'T',
17: 'V',
18: 'W',
19: 'Y',
20: 'X',
}
STANDARD_ATOM_MASK = _make_standard_atom_mask()
# Path: frame2seq/utils/util.py
def get_neg_pll(probs, seq):
seq_probs = torch.gather(probs, 1, seq.unsqueeze(-1)).squeeze(-1)
neg_pll = -1 * torch.log(seq_probs)
avg_neg_pll = neg_pll.sum().item() / len(neg_pll)
return neg_pll, avg_neg_pll
# Path: frame2seq/utils/util.py
def read_fasta_file(fasta_file):
"""
Read a fasta file and return a list of sequences.
"""
with open(fasta_file, 'r') as f:
lines = f.readlines()
sequences = []
for line in lines:
if line[0] == '>':
sequences.append(lines[lines.index(line) + 1].strip())
return sequences
# Path: frame2seq/utils/pdb2input.py
def get_inference_inputs(pdb_file, chain_id):
atom_positions, aatype, seq_mask = get_parsed_inputs(pdb_file, chain_id)
seq_mask = seq_mask.unsqueeze(0)
aatype = torch.from_numpy(aatype)
aatype = aatype.unsqueeze(0)
X = atom_positions
X = X.unsqueeze(0)
return seq_mask, aatype, X
# Path: frame2seq/utils/pred2output.py
def output_csv(preds, csv_dir):
"""
Given average negative pseudo-log-likelihoods, write to a csv file.
"""
df = pd.DataFrame(columns=[
'PDBID', 'Chain ID', 'Sample Number', 'Scored sequence',
'Average negative pseudo-log-likelihood', 'Temperature'
],
data=preds)
df.to_csv(f"{csv_dir}/scores.csv", index=False)
# Path: frame2seq/utils/pred2output.py
def output_indiv_csv(scores, csv_dir):
"""
Given per-residue negative pseudo-log-likelihoods, write to a csv file.
"""
pdbid = scores['pdbid']
chain = scores['chain']
sample = scores['sample']
res_idx = scores['res_idx']
neg_pll = scores['neg_pll']
df = pd.DataFrame(
list(zip(res_idx, neg_pll)),
columns=['Residue index', 'Negative pseudo-log-likelihood'])
df.to_csv(f"{csv_dir}/{pdbid}_{chain}_seq{sample}.csv", index=False)
# Path: frame2seq/utils/score.py
import os
import torch
from tqdm import tqdm
from frame2seq.utils import residue_constants
from frame2seq.utils.util import get_neg_pll, read_fasta_file
from frame2seq.utils.pdb2input import get_inference_inputs
from frame2seq.utils.pred2output import output_csv, output_indiv_csv
def score(self, pdb_file, chain_id, fasta_file, save_indiv_neg_pll):
temperature = 1.0
seq_mask, aatype, X = get_inference_inputs(pdb_file, chain_id)
seq_mask = seq_mask.to(self.device)
aatype = aatype.to(self.device)
X = X.to(self.device)
str_form = [residue_constants.ID_TO_AA[int(i)] for i in aatype[0]]
input_aatype_onehot = residue_constants.sequence_to_onehot(
sequence=str_form,
mapping=residue_constants.AA_TO_ID,
)
input_aatype_onehot = torch.from_numpy(input_aatype_onehot).float()
input_aatype_onehot = input_aatype_onehot.unsqueeze(0)
input_aatype_onehot = input_aatype_onehot.to(self.device)
input_aatype_onehot = torch.zeros_like(input_aatype_onehot)
input_aatype_onehot[:, :,
20] = 1 # all positions are masked (set to unknown)
scores, preds = {}, []
with torch.no_grad():
pred_seq1 = self.models[0].forward(X, seq_mask, input_aatype_onehot)
pred_seq2 = self.models[1].forward(X, seq_mask, input_aatype_onehot)
pred_seq3 = self.models[2].forward(X, seq_mask, input_aatype_onehot)
pred_seq = (pred_seq1 + pred_seq2 + pred_seq3) / 3 # ensemble
pred_seq = pred_seq / temperature
pred_seq = torch.nn.functional.softmax(pred_seq, dim=-1)
pred_seq = pred_seq[seq_mask]
if fasta_file is not None:
| input_seqs = read_fasta_file(fasta_file) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: davep/oshit
# Path: oshit/app/data/config.py
@lru_cache(maxsize=None)
def load_configuration() -> Configuration:
"""Load the configuration.
Returns:
The configuration.
Note:
As a side-effect, if the configuration doesn't exist a default one
will be saved to storage.
This function is designed so that it's safe and low-cost to
repeatedly call it. The configuration is cached and will only be
loaded from storage when necessary.
"""
source = configuration_file()
return (
Configuration(**loads(source.read_text(encoding="utf-8")))
if source.exists()
else save_configuration(Configuration())
)
# Path: oshit/app/data/config.py
def save_configuration(configuration: Configuration) -> Configuration:
"""Save the given configuration.
Args:
The configuration to store.
Returns:
The configuration.
"""
load_configuration.cache_clear()
configuration_file().write_text(
dumps(asdict(configuration), indent=4), encoding="utf-8"
)
return load_configuration()
# Path: oshit/app/screens/main.py
class Main(Screen[None]):
"""The main screen of the application."""
CONTEXT_HELP = """
## Application keys
| Key | Description |
| - | - |
| <kbd>F1</kbd> | This help screen. |
| <kbd>F2</kbd> | Toggle compact/relaxed display. |
| <kbd>F3</kbd> | Toggle dark/light mode. |
| <kbd>F12</kbd> | Quit the application. |
| <kbd>t</kbd> | View the top stories. |
| <kbd>n</kbd> | View the new stories. |
| <kbd>b</kbd> | View the best stories. |
| <kbd>a</kbd> | View the AskHN stories. |
| <kbd>s</kbd> | View the ShowHN stories. |
| <kbd>j</kbd> | View the jobs. |
"""
CSS = """
TabbedContent, LoadingIndicator {
background: $panel;
}
"""
TITLE = f"Orange Site Hit v{__version__}"
BINDINGS = [
Binding("f1", "help", "Help"),
Binding("f2", "compact", "Compact/Relaxed"),
Binding("f3", "toggle_dark"),
Binding("f12", "quit", "Quit"),
Binding("t", "go('top')"),
Binding("n", "go('new')"),
Binding("b", "go('best')"),
Binding("a", "go('ask')"),
Binding("s", "go('show')"),
Binding("j", "go('jobs')"),
Binding("down, enter", "pane"),
]
def __init__(self) -> None:
"""Initialise the screen."""
super().__init__()
config = load_configuration()
self._hn = HN(
max_concurrency=config.maximum_concurrency,
timeout=config.connection_timeout,
)
"""The HackerNews client object."""
def compose(self) -> ComposeResult:
"""Compose the main screen's layout."""
yield Header()
with HackerNews():
yield Items("top", "t", self._hn.top_stories)
yield Items("new", "n", self._hn.new_stories)
yield Items("best", "b", self._hn.best_stories)
yield Items("ask", "a", self._hn.latest_ask_stories)
yield Items("show", "s", self._hn.latest_show_stories)
yield Items("jobs", "j", self._hn.latest_job_stories)
yield Footer()
def _refresh_subtitle(self) -> None:
"""Refresh the subtitle of the screen."""
self.sub_title = self.query_one(HackerNews).description
def on_mount(self) -> None:
"""Configure things once the DOM is ready."""
self.set_interval(0.95, self._refresh_subtitle)
def action_help(self) -> None:
"""Show the help screen."""
self.app.push_screen(Help(self))
def action_go(self, items: str) -> None:
"""Go to the given list of items.
Args:
items: The name of the list of items to go to.
"""
self.query_one(HackerNews).active = items
self.query_one(HackerNews).focus_active_pane()
def action_compact(self) -> None:
"""Toggle the compact display."""
news = self.query_one(HackerNews)
news.compact = not news.compact
@on(ShowUser)
def show_user(self, event: ShowUser) -> None:
"""Handle a request to show the details of a user."""
self.app.push_screen(UserDetails(self._hn, event.user))
@on(ShowComments)
def show_comments(self, event: ShowComments) -> None:
"""Handle a request to show the comments for an article."""
self.app.push_screen(Comments(self._hn, event.article))
# Path: oshit/app/oshit.py
from textual.app import App
from .data import load_configuration, save_configuration
from .screens import Main
"""The main application class."""
##############################################################################
# Textual imports.
##############################################################################
# Local imports.
##############################################################################
class OSHit(App[None]):
"""The Orange Site Hit application."""
ENABLE_COMMAND_PALETTE = False
def __init__(self) -> None:
"""Initialise the application."""
super().__init__()
self.dark = load_configuration().dark_mode
def on_mount(self) -> None:
"""Get things going once the app is up and running."""
| self.push_screen(Main()) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Maximilian-Winter/llama-cpp-agent
# Path: src/llama_cpp_agent/function_calling.py
class LlamaCppFunctionTool:
def __init__(self, pydantic_model: Type[BaseModel], has_markdown_code_block=False, has_triple_quoted_string=False,
**additional_parameters):
self.model = pydantic_model
self.look_for_field_string = has_markdown_code_block or has_triple_quoted_string
self.has_markdown_code_block = has_markdown_code_block
self.has_triple_quoted_string = has_triple_quoted_string
self.additional_parameters = additional_parameters if additional_parameters else {}
def __call__(self, *args, **kwargs):
return self.model(**kwargs)
# Path: src/llama_cpp_agent/agent_memory/core_memory_manager.py
class CoreMemoryManager:
def __init__(self, core_memory: dict):
self.core_memory = core_memory
def add_to_core_memory(self, key: str, child_key: str, value) -> str:
"""
Adds or updates an entry in the core memory.
"""
if key not in self.core_memory:
self.core_memory[key] = {}
self.core_memory[key][child_key] = value
return f"Core memory updated. Key: {key}, Child Key: {child_key}"
def replace_in_core_memory(self, key: str, child_key: str, new_value) -> str:
"""
Replaces an existing entry in the core memory.
"""
if key in self.core_memory and child_key in self.core_memory[key]:
self.core_memory[key][child_key] = new_value
return f"Core memory replaced. Key: {key}, Child Key: {child_key}"
else:
return "Key or child key not found in core memory."
def remove_from_core_memory(self, key: str, child_key: str) -> str:
"""
Removes a specific field from a core memory entry.
"""
if key in self.core_memory and child_key in self.core_memory[key]:
del self.core_memory[key][child_key]
return f"Core memory entry removed. Key: {key}, Child Key: {child_key}"
else:
return "Key or child key not found in core memory."
def build_core_memory_context(self):
output = json.dumps(self.core_memory, indent=4)
context = f"# Core-Memory:\n{output if output != '{}' else 'Empty'}"
return context
def load(self, file_path):
with open(file_path, 'r', encoding='utf-8') as file:
self.core_memory = json.load(file)
def save(self, file_path):
with open(file_path, 'w', encoding='utf-8') as file:
json.dump(self.core_memory, file, indent=4)
# Path: src/llama_cpp_agent/agent_memory/retrieval_memory_manager.py
class RetrievalMemoryManager:
def __init__(self, retrieval_memory: RetrievalMemory):
def add_memory_to_retrieval(self, description: str, importance: float = 1.0) -> str:
def retrieve_memories(self, query: str, max_results: int = 5) -> str:
# Path: src/llama_cpp_agent/agent_memory/memory_tools.py
from pydantic import BaseModel, Field
from ..function_calling import LlamaCppFunctionTool
from .core_memory_manager import CoreMemoryManager
from .retrieval_memory_manager import RetrievalMemoryManager, RetrievalMemory
class AddCoreMemory(BaseModel):
"""
Add a new entry to the core memory.
"""
key: str = Field(..., description="The key identifier for the core memory entry.")
field: str = Field(..., description="A secondary key or field within the core memory entry.")
value: str = Field(..., description="The value or data to be stored in the specified core memory entry.")
def run(self, core_memory_manager: CoreMemoryManager):
return core_memory_manager.add_to_core_memory(self.key, self.field, self.value)
# Replace Core Memory Model
class ReplaceCoreMemory(BaseModel):
"""
Replace an entry in the core memory.
"""
key: str = Field(..., description="The key identifier for the core memory entry.")
field: str = Field(..., description="The specific field within the core memory entry to be replaced.")
new_value: str = Field(...,
description="The new value to replace the existing data in the specified core memory field.")
def run(self, core_memory_manager: CoreMemoryManager):
return core_memory_manager.replace_in_core_memory(self.key, self.field, self.value)
class RemoveCoreMemory(BaseModel):
"""
Remove an entry in the core memory.
"""
key: str = Field(..., description="The key identifier for the core memory entry to be removed.")
field: str = Field(..., description="The specific field within the core memory entry to be removed.")
def run(self, core_memory_manager: CoreMemoryManager):
return core_memory_manager.remove_from_core_memory(self.key, self.field)
class RetrieveMemories(BaseModel):
"""
Retrieve memories from the retrieval memory based on a query.
"""
query: str = Field(..., description="The query to be used to retrieve memories from the retrieval memory.")
def run(self, retrieval_memory_manager: RetrievalMemoryManager):
return retrieval_memory_manager.retrieve_memories(self.query)
class AddRetrievalMemory(BaseModel):
"""
Add memory to the retrieval memory.
"""
memory: str = Field(..., description="The memory to be added to the retrieval memory.")
importance: float = Field(..., description="The importance of the memory to be added to the retrieval memory.")
def run(self, retrieval_memory_manager: RetrievalMemoryManager):
return retrieval_memory_manager.add_memory_to_retrieval(self.memory, self.importance)
class AgentRetrievalMemory:
def __init__(self, persistent_db_path="./retrieval_memory", embedding_model_name="all-MiniLM-L6-v2",
collection_name="retrieval_memory_collection"):
| self.retrieval_memory = RetrievalMemory(persistent_db_path, embedding_model_name, collection_name) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: tedivm/paracelsus
# Path: paracelsus/transformers/dot.py
class Dot:
comment_format: str = "dot"
metadata: MetaData
graph: pydot.Dot
def __init__(self, metaclass: MetaData) -> None:
self.metadata = metaclass
self.graph = pydot.Dot("database", graph_type="graph")
for table in self.metadata.tables.values():
node = pydot.Node(name=table.name)
node.set_label(self._table_label(table))
node.set_shape("none")
node.set_margin("0")
self.graph.add_node(node)
for column in table.columns:
for foreign_key in column.foreign_keys:
key_parts = foreign_key.target_fullname.split(".")
left_table = key_parts[0]
left_column = key_parts[1]
edge = pydot.Edge(left_table, table.name)
edge.set_label(column.name)
edge.set_dir("both")
edge.set_arrowhead("none")
if not column.unique:
edge.set_arrowhead("crow")
l_column = self.metadata.tables[left_table].columns[left_column]
edge.set_arrowtail("none")
if not l_column.unique and not l_column.primary_key:
edge.set_arrowtail("crow")
self.graph.add_edge(edge)
def _table_label(self, table: Table) -> str:
column_output = ""
columns = sorted(table.columns, key=utils.column_sort_key)
for column in columns:
attributes = set([])
if column.primary_key:
attributes.add("Primary Key")
if len(column.foreign_keys) > 0:
attributes.add("Foreign Key")
if column.unique:
attributes.add("Unique")
column_output += f' <tr><td align="left">{column.type}</td><td align="left">{column.name}</td><td>{", ".join(sorted(attributes))}</td></tr>\n'
return f"""<
<table border="0" cellborder="1" cellspacing="0" cellpadding="4">
<tr><td colspan="3" bgcolor="lightblue"><b>{table.name}</b></td></tr>
{column_output.rstrip()}
</table>
>"""
def __str__(self) -> str:
return self.graph.to_string()
# Path: paracelsus/transformers/mermaid.py
class Mermaid:
comment_format: str = "mermaid"
metadata: MetaData
def __init__(self, metaclass: MetaData) -> None:
self.metadata = metaclass
def _table(self, table: Table) -> str:
output = f"\t{table.name}"
output += " {\n"
columns = sorted(table.columns, key=utils.column_sort_key)
for column in columns:
output += self._column(column)
output += "\t}\n\n"
return output
def _column(self, column: Column) -> str:
column_str = f"{column.type} {column.name}"
if column.primary_key:
if len(column.foreign_keys) > 0:
column_str += " PK,FK"
else:
column_str += " PK"
elif len(column.foreign_keys) > 0:
column_str += " FK"
options = []
if column.nullable:
options.append("nullable")
if column.unique:
options.append("unique")
if column.index:
options.append("indexed")
if len(options) > 0:
column_str += f' "{",".join(options)}"'
return f"\t\t{column_str}\n"
def _relationships(self, column: Column) -> str:
output = ""
column_name = column.name
right_table = column.table.name
if column.unique:
right_operand = "o|"
else:
right_operand = "o{"
for foreign_key in column.foreign_keys:
key_parts = foreign_key.target_fullname.split(".")
left_table = key_parts[0]
left_column = key_parts[1]
left_operand = ""
lcolumn = self.metadata.tables[left_table].columns[left_column]
if lcolumn.unique or lcolumn.primary_key:
left_operand = "||"
else:
left_operand = "}o"
output += f"\t{left_table} {left_operand}--{right_operand} {right_table} : {column_name}\n"
return output
def __str__(self) -> str:
output = "erDiagram\n"
for table in self.metadata.tables.values():
output += self._table(table)
for table in self.metadata.tables.values():
for column in table.columns.values():
if len(column.foreign_keys) > 0:
output += self._relationships(column)
return output
# Path: paracelsus/cli.py
import importlib
import re
import sys
import typer
from enum import Enum
from pathlib import Path
from typing import List
from typing_extensions import Annotated
from .transformers.dot import Dot
from .transformers.mermaid import Mermaid
from . import _version
app = typer.Typer()
transformers = {
"mmd": Mermaid,
"mermaid": Mermaid,
| "dot": Dot, |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: winniesi/tg-gemini-bot
# Path: api/auth.py
def is_authorized(from_id: int, user_name: str) -> bool:
if str(user_name) in ALLOWED_USERS:
return True
return False
# Path: api/context.py
class ChatManager:
"""setting up a basic conversation storage manager"""
def __init__(self):
self.chats: Dict[str, ChatConversation] = {}
def _new_chat(self, username: str) -> ChatConversation:
chat = ChatConversation()
self.chats[username] = chat
return chat
def get_chat(self, username: str) -> ChatConversation:
if self.chats.get(username) is None:
return self._new_chat(username)
return self.chats[username]
# Path: api/context.py
class ImageChatManger:
def __init__(self, prompt, file_id: str) -> None:
self.prompt = prompt
self.file_id = file_id
def tel_photo_url(self) -> str:
"""process telegram photo url"""
r_file_id = requests.get(
f"https://api.telegram.org/bot{BOT_TOKEN}/getFile?file_id={self.file_id}"
)
file_path = r_file_id.json().get("result").get("file_path")
download_url = f"https://api.telegram.org/file/bot{BOT_TOKEN}/{file_path}"
return download_url
def photo_bytes(self) -> BytesIO:
"""get photo bytes"""
photo_url = self.tel_photo_url()
response = requests.get(photo_url)
photo_bytes = BytesIO(response.content)
return photo_bytes
def send_image(self) -> str:
response = generate_text_with_image(self.prompt, self.photo_bytes())
return response
# Path: api/telegram.py
class Update:
def __init__(self, update: Dict) -> None:
self.update = update
self.from_id = update["message"]["from"]["id"]
self.type = self._type()
self.text = self._text()
self.photo_caption = self._photo_caption()
self.file_id = self._file_id()
self.user_name = update["message"]["from"]["username"]
def _type(self):
if "text" in self.update["message"]:
return "text"
elif "photo" in self.update["message"]:
return "photo"
else:
return ""
def _photo_caption(self):
if self.type == "photo":
return self.update["message"].get("caption", "describe the photo")
return ""
def _text(self):
if self.type == "text":
return self.update["message"]["text"]
return ""
def _file_id(self):
if self.type == "photo":
return self.update["message"]["photo"][0]["file_id"]
return ""
# Path: api/telegram.py
def send_message(chat_id, text):
"""send text message"""
payload = {
"chat_id": chat_id,
"text": escape(text),
"parse_mode": "MarkdownV2",
}
r = requests.post(f"{TELEGRAM_API}/sendMessage", data=payload)
print(f"Sent message: {text} to {chat_id}")
return r
# Path: api/handle.py
from .auth import is_authorized
from .context import ChatManager, ImageChatManger
from .telegram import Update, send_message
"""
All the chat that comes through the Telegram bot gets passed to the
handle_message function. This function checks out if the user has the
green light to chat with the bot. Once that's sorted, it figures out if
the user sent words or an image and deals with it accordingly.
For text messages, it fires up the ChatManager class that keeps track of
the back-and-forth with that user.
As for images, in Gemini pro, they're context-free, so you can handle
them pretty straight-up without much fuss.
"""
chat_manager = ChatManager()
def handle_message(update_data):
update = Update(update_data)
authorized = is_authorized(update.from_id, update.user_name)
if not authorized:
| send_message(update.from_id, "😫 You are not allowed to use this bot.") |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: usail-hkust/LLMTSCS
# Path: utils/utils.py
def oneline_wrapper(dic_agent_conf, dic_traffic_env_conf, dic_path, roadnet, trafficflow):
results_table = []
all_rewards = []
all_queue_len = []
all_travel_time = []
for i in range(1):
dic_path["PATH_TO_MODEL"] = (dic_path["PATH_TO_MODEL"].split(".")[0] + ".json" +
time.strftime('%m_%d_%H_%M_%S', time.localtime(time.time())))
dic_path["PATH_TO_WORK_DIRECTORY"] = (dic_path["PATH_TO_WORK_DIRECTORY"].split(".")[0] + ".json" +
time.strftime('%m_%d_%H_%M_%S', time.localtime(time.time())))
oneline = OneLine(dic_agent_conf=dic_agent_conf,
dic_traffic_env_conf=merge(config.dic_traffic_env_conf, dic_traffic_env_conf),
dic_path=merge(config.DIC_PATH, dic_path),
roadnet=roadnet,
trafficflow=trafficflow
)
round_results = oneline.train(round=i)
results_table.append([round_results['test_reward_over'], round_results['test_avg_queue_len_over'],
round_results['test_avg_travel_time_over']])
all_rewards.append(round_results['test_reward_over'])
all_queue_len.append(round_results['test_avg_queue_len_over'])
all_travel_time.append(round_results['test_avg_travel_time_over'])
# delete junk
cmd_delete_model = 'rm -rf <dir>'.replace("<dir>", dic_path["PATH_TO_MODEL"])
cmd_delete_work = 'find <dir> -type f ! -name "state_action.json" -exec rm -rf {} \;'.replace("<dir>", dic_path["PATH_TO_WORK_DIRECTORY"])
os.system(cmd_delete_model)
os.system(cmd_delete_work)
results_table.append([np.average(all_rewards), np.average(all_queue_len), np.average(all_travel_time)])
results_table.append([np.std(all_rewards), np.std(all_queue_len), np.std(all_travel_time)])
table_logger = wandb.init(
project=dic_traffic_env_conf['PROJECT_NAME'],
group=f"{dic_traffic_env_conf['MODEL_NAME']}-{roadnet}-{trafficflow}-{len(dic_agent_conf['FIXED_TIME'])}_Phases",
name="exp_results",
config=merge(merge(dic_agent_conf, dic_path), dic_traffic_env_conf),
)
columns = ["reward", "avg_queue_len", "avg_travel_time"]
logger_table = wandb.Table(columns=columns, data=results_table)
table_logger.log({"results": logger_table})
wandb.finish()
return
# Path: utils/error.py
class flowFileException(Exception):
def __init__(self, message):
def __str__(self):
# Path: run_advanced_maxpressure.py
from utils.utils import oneline_wrapper
from utils import error
from multiprocessing import Process
import os
import time
import argparse
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--memo", type=str, default='AdvancedMaxPressure')
parser.add_argument("--model", type=str, default="AdvancedMaxPressure")
parser.add_argument("--proj_name", type=str, default="chatgpt-TSCS")
parser.add_argument("--eightphase", action="store_true", default=False)
parser.add_argument("--multi_process", action="store_true", default=True)
parser.add_argument("--workers", type=int, default=1)
parser.add_argument("--dataset", type=str, default="template")
parser.add_argument("--traffic_file", type=str, default="flow_main_stream.json")
return parser.parse_args()
def main(in_args):
traffic_file_list = []
if in_args.dataset == 'jinan':
count = 3600
road_net = "3_4"
traffic_file_list = ["anon_3_4_jinan_real.json", "anon_3_4_jinan_real_2000.json", "anon_3_4_jinan_real_2500.json"]
template = "Jinan"
elif in_args.dataset == 'hangzhou':
count = 3600
road_net = "4_4"
traffic_file_list = ["anon_4_4_hangzhou_real.json", "anon_4_4_hangzhou_real_5816.json"]
template = "Hangzhou"
elif in_args.dataset == 'newyork_16x3':
count = 3600
road_net = "16_3"
traffic_file_list = ["anon_16_3_newyork_real.json"]
template = "NewYork"
elif in_args.dataset == 'newyork_28x7':
count = 3600
road_net = "28_7"
traffic_file_list = ["anon_28_7_newyork_real_double.json", "anon_28_7_newyork_real_triple.json"]
template = "NewYork"
elif in_args.dataset == 'template':
count = 3600
road_net = "1_1"
traffic_file_list = ["flow_main_stream.json"]
template = "template"
# flow_file error
try:
if in_args.traffic_file not in traffic_file_list:
| raise error.flowFileException('Flow file does not exist.') |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ohadmata/shmessy
# Path: src/shmessy/schema.py
class InferredField(BaseModel):
inferred_type: Optional[str] = None
inferred_pattern: Optional[Any] = None
# Path: src/shmessy/schema.py
class ValidatorTypes(str, Enum):
NUMERIC = "NUMERIC"
STRING = "STRING"
# Path: src/shmessy/types/base.py
class BaseType(ABC):
weight: int = 0
validator_types: Tuple[ValidatorTypes]
@abstractmethod
def validate(self, data: ndarray) -> Optional[InferredField]:
pass
@abstractmethod
def fix(self, column: Series, inferred_field: InferredField) -> Series:
pass
def is_validator_type_valid(self, dtype: Type) -> bool:
for possible_validator_type in self.validator_types:
if self._check_single_validator_type(dtype, possible_validator_type):
return True
return False
@staticmethod
def _check_single_validator_type(
dtype: Type, possible_validator_type: ValidatorTypes
) -> bool:
if possible_validator_type == ValidatorTypes.NUMERIC and not issubdtype(
dtype, number
):
return False
if possible_validator_type == ValidatorTypes.STRING and not (
issubdtype(dtype, object_) or issubdtype(dtype, str_)
):
return False
return True
@property
def name(self) -> str:
return str(self.__class__.__name__.replace("Type", ""))
# Path: src/shmessy/types/unix_timestamp.py
import logging
import math
from datetime import datetime
from enum import Enum
from typing import Optional
from numpy import ndarray
from pandas import Series, to_datetime
from ..schema import InferredField, ValidatorTypes
from .base import BaseType
logger = logging.getLogger(__name__)
class TimestampResolution(str, Enum):
SECONDS = "s"
MILLISECONDS = "ms"
NANOSECONDS = "ns"
class UnixTimestampType(BaseType):
weight = 4
validator_types = (ValidatorTypes.NUMERIC,)
min_valid_year: int = 1980
max_valid_year: int = 2100
@staticmethod
def _unix_timestamp_resolution(value: float) -> TimestampResolution:
number_of_digits = len(str(int(value)))
if number_of_digits == 10:
return TimestampResolution.SECONDS
if number_of_digits == 13:
return TimestampResolution.MILLISECONDS
if number_of_digits == 16:
return TimestampResolution.NANOSECONDS
@staticmethod
def _fix_input_resolution(
value: float, selected_resolution: TimestampResolution
) -> float:
if selected_resolution == TimestampResolution.SECONDS:
return value
if selected_resolution == TimestampResolution.MILLISECONDS:
return value / 1000
if selected_resolution == TimestampResolution.NANOSECONDS:
return value / 1000 / 1000
| def validate(self, data: ndarray) -> Optional[InferredField]: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: kokiez/solana-sniper
# Path: birdeye.py
def get_price(token_address):
url = f"https://api.dexscreener.com/latest/dex/tokens/{token_address}"
exclude = ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB']
response = requests.get(url).json()
if token_address not in exclude:
for pair in response['pairs']:
if pair['quoteToken']['address'] == 'So11111111111111111111111111111111111111112':
return float(pair['priceUsd'])
else:
return response['pairs'][0]['priceUsd']
return None
# Path: birdeye.py
def getSymbol(token):
# usdc and usdt
exclude = ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB']
if token not in exclude:
url = f"https://api.dexscreener.com/latest/dex/tokens/{token}"
Token_Symbol = ""
Sol_symbol=""
try:
response = requests.get(url)
# Check if the request was successful (status code 200)
if response.status_code == 200:
resp = response.json()
print("Response:",resp['pairs'][0]['baseToken']['symbol'])
for pair in resp['pairs']:
quoteToken = pair['quoteToken']['symbol']
if quoteToken == 'SOL':
Token_Symbol = pair['baseToken']['symbol']
Sol_symbol = quoteToken
return Token_Symbol, Sol_symbol
else:
print(f"[getSymbol] Request failed with status code {response.status_code}")
except requests.exceptions.RequestException as e:
print(f"[getSymbol] error occurred: {e}")
except:
a = 1
return Token_Symbol, Sol_symbol
else:
if token == 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v':
return "USDC", "SOL"
elif token == 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v':
return "USDT", "SOL"
# Path: webhook.py
def sendWebhook(title_type_info, description):
global error_webhook
global webhook_url
title = ""
title_type = title_type_info.split("|")
if title_type[0] == "msg":
title = title_type[1]
color = colors["Green"]
webhook(title, color, description, webhook_url)
elif title_type[0] == "msg_b":
title = title_type[1]
color = colors["DarkAqua"]
webhook(title, color, description, webhook_url)
elif title_type[0] == "msg_s":
title = title_type[1]
color = colors["DarkAqua"]
webhook(title, color, description, webhook_url)
elif title_type[0] == "i_s": #invest or slippage was changed etc
title = title_type[1]
color = colors["DarkPurple"]
webhook(title, color, description, webhook_url)
elif title_type[0] == "e": #error
title = title_type[1]
color = colors["DarkRed"]
webhook(title, color, description, error_webhook)
elif title_type[0] == "a": #alert
title = title_type[1]
color = colors["LuminousVividPink"]
webhook(title, color, description, webhook_url)
elif title_type[0] == "w": #wallet info
title = title_type[1]
color = colors["Gold"]
webhook(title, color, description, webhook_url)
# Path: monitor_price_strategy.py
import time
from birdeye import get_price, getSymbol
from webhook import sendWebhook
"""If you have ton of trades then best to use Simulate Transaction and modify this part of code to your needs"""
"""
Only Take Profit
"""
def limit_order(bought_token_price,desired_token_address, take_profit_ratio, execution_time, txB):
token_symbol, SOl_Symbol = getSymbol(desired_token_address)
# CALCULATE SELL LIMIT
sell_limit_token_price = bought_token_price * take_profit_ratio
print("-" * 79)
print(f"| {'Bought Price':<12} | {'Sell Limit':<12} | {'Tx Buy':<50} |")
print("-" * 79)
print(f"|{bought_token_price:.12f} | {sell_limit_token_price:.12f} {txB:<50} |")
print("-" * 79)
sendWebhook(f"msg_b|BUY INFO {token_symbol}",f"Bought Price: {bought_token_price:.12f}\n**Sell Limit: {sell_limit_token_price:.15f}**\nTotal Buy Execution time: {execution_time} seconds\nBuy TXN: https://solscan.io/tx/{txB} |")
# LOOP = CHECK IF PRICE >= SELL LIMIT | checks price every 5 seconds
priceLow = True
# while priceLow and isTimePassed(time_limit) == False:
while priceLow:
# Check if time limit has been passed for the token bought or not
| bought_token_curr_price = get_price(desired_token_address)
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: enochyearn/MLX_RoBERTa
# Path: custom/nn/layers/normalization.py
class LayerNormBasselCorrected(Module):
r"""Applies layer normalization [1] on the inputs with Bessel's Correction used by default like PyTorch.
Computes
.. math::
y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
where :math:`\gamma` and :math:`\beta` are learned per feature dimension
parameters initialized at 1 and 0 respectively.
Var[x] would by default apply Bessel's Correction.
[1]: https://arxiv.org/abs/1607.06450
Args:
dims (int): The feature dimension of the input to normalize over
eps (float): A small additive constant for numerical stability
affine (bool): If True learn an affine transform to apply after the
normalization
correction (bool):
"""
def __init__(self, dims: int, eps: float = 1e-5, affine: bool = True, correction: bool = True):
super().__init__()
if affine:
self.bias = mx.zeros((dims,))
self.weight = mx.ones((dims,))
self.eps = eps
self.dims = dims
self.correction = correction
def _extra_repr(self):
return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
def __call__(self, x):
means = mx.mean(x, axis=-1, keepdims=True)
var = mx.var(x, axis=-1, keepdims=True, ddof=int(self.correction))
x = (x - means) * mx.rsqrt(var + self.eps)
return (self.weight * x + self.bias) if "weight" in self else x
# Path: custom/nn/layers/normalization.py
class LayerNormTorchAlike(Module):
r"""Applies layer normalization [1] on the inputs in PyTorch's style.
MLX's official LayerNorm has a different behavior with PyTorch's.
Computes
.. math::
y = \frac{x - E[x]}{\sqrt{Var[x]} + \epsilon} \gamma + \beta,
where :math:`\gamma` and :math:`\beta` are learned per feature dimension
parameters initialized at 1 and 0 respectively.
Var[x] would by default apply Bessel's Correction.
[1]: https://arxiv.org/abs/1607.06450
Args:
dims (int): The feature dimension of the input to normalize over
eps (float): A small additive constant for numerical stability
affine (bool): If True learn an affine transform to apply after the
normalization
correction (bool):
"""
def __init__(self, dims: int, eps: float = 1e-5, affine: bool = True, correction: bool = True):
super().__init__()
if affine:
self.bias = mx.zeros((dims,))
self.weight = mx.ones((dims,))
self.eps = eps
self.dims = dims
self.correction = correction
def _extra_repr(self):
return f"{self.dims}, eps={self.eps}, affine={'weight' in self}"
def __call__(self, x):
# Calculate the mean of all elements;
# i.e. the means for each element $\mathbb{E}[X]$
mean = x.mean(axis=-1, keepdims=True)
# Calculate the squared mean of all elements;
# i.e. the means for each element $\mathbb{E}[X^2]$
mean_x2 = (x ** 2).mean(axis=-1, keepdims=True)
# Variance of all element $Var[X] = \mathbb{E}[X^2] - \mathbb{E}[X]^2$
var = mean_x2 - mean ** 2
# Normalize $$\hat{X} = \frac{X - \mathbb{E}[X]}{\sqrt{Var[X] + \epsilon}}$$
x_norm = (x - mean) / mx.sqrt(var + self.eps)
# Scale and shift $$\text{LN}(x) = \gamma \hat{X} + \beta$$
x_norm = self.weight * x_norm + self.bias
return x_norm
# Path: mlx_roberta.py
import argparse
import time
import mlx.core as mx
import mlx.nn as nn
import numpy as np
import math
from mlx.utils import tree_unflatten
from collections import OrderedDict
from custom.nn.layers.normalization import LayerNormBasselCorrected, LayerNormTorchAlike
from transformers import RobertaTokenizer
from dataclasses import dataclass
# utils
@dataclass
class ModelConfig:
intermediate_size: int = 3072
hidden_size: int = 768
no_heads: int = 12
hidden_layers: int = 12
vocab_size: int = 50265
attention_probs_dropout_prob: float = 0.1
hidden_dropout_prob: float = 0.1
layer_norm_eps: float = 1e-5
max_position_embeddings: int = 514
# QA model's parameters
num_labels: int = 2
type_vocab_size: int = 2
pad_token_id: int = 1
chunk_size_feed_forward: int = 0
model_configs = {
"deepset/roberta-base-squad2": ModelConfig(),
"roberta-base": ModelConfig(),
}
model_types = {
"deepset/roberta-base-squad2": "qa",
"roberta-base": "base",
}
class RobertaEmbeddings(nn.Module):
def __init__(self, config):
super().__init__()
self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size)
self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
| self.LayerNorm = LayerNormTorchAlike(config.hidden_size, eps=config.layer_norm_eps, correction=True) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: zy7y/dfs-generate
# Path: entity.py
class CodeGen(BaseVo):
name: str
code: str
@field_serializer("code")
def serialize_code(self, code: str, _info):
_code = black.format_str(code, mode=black.FileMode())
return isort.code(_code)
# Path: entity.py
class Conf(SQLModel, table=True):
__tablename__ = "dfs_conf"
id: int = Field(None, primary_key=True)
db_uri: str = Field(..., description="数据库连接")
@classmethod
def get_db_uri_last_new(cls):
"""获取最新的db_url"""
with Session(engine) as session:
query = select(cls).order_by(cls.id.desc())
latest_conf = session.exec(query).first()
if latest_conf:
return latest_conf.db_uri
else:
return None
@classmethod
def create(cls, uri) -> "Conf":
with Session(engine) as session:
obj = cls(db_uri=uri)
session.add(obj)
session.commit()
session.refresh(obj)
return obj
@classmethod
def get_last_uri_with_metadata(cls):
uri = cls.get_db_uri_last_new()
return uri, get_metadata_by_db_uri(uri)
# Path: entity.py
class DBConf(SQLModel):
user: str
password: str
port: int
host: str
db: str
def get_db_uri(self):
return f"mysql+pymysql://{self.user}:{self.password}@{self.host}:{self.port}/{self.db}"
def get_metadata(self):
return get_metadata_by_db_uri(self.get_db_uri())
# Path: entity.py
class R(BaseModel, Generic[T]):
code: int = 20000
msg: str = "ok"
data: Optional[T] = None
@classmethod
def success(cls, **kwargs):
return cls(**kwargs)
@classmethod
def error(cls, msg):
return cls(code=40000, msg=msg)
# Path: entity.py
class RList(R[T]):
data: List[T] = Field(default_factory=list)
# Path: entity.py
class Table(BaseVo):
table_name: str
table_comment: Optional[str] = None
# Path: generate/main.py
def generate_code(table: Table, uri: str):
return [
{"name": "model.py", "code": GenerateEntity(table).render()},
{"name": "router.py", "code": render_router(table.name)},
{"name": "main.py", "code": render_main(table.name)},
{"name": "db.py", "code": render_db(uri)},
]
# Path: main.py
from fastapi import FastAPI, Query
from fastapi.requests import Request
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from entity import CodeGen, Conf, DBConf, R, RList, Table
from generate.main import generate_code
import uvicorn
app = FastAPI(
title="dfs-generate", description="FastAPI SQLModel 逆向生成代码", docs_url=None
)
app.mount("/static", StaticFiles(directory="static"), name="static")
@app.get("/", include_in_schema=False)
def index():
return FileResponse("static/index.html")
| @app.get("/tables", response_model=RList[Table]) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: CrawlScript/Torch-MGDCF
# Path: torch_mgdcf/metrics/ranking.py
def ndcg_score(reference, hypothesis):
"""
Normalized Discounted Cumulative Gain (nDCG)
Normalized version of DCG:
nDCG = DCG(hypothesis)/DCG(reference)
Parameters:
reference - a gold standard (perfect) ordering Ex: [5,4,3,2,1]
hypothesis - a proposed ordering Ex: [5,2,2,3,1]
Returns:
ndcg_score - normalized score
"""
return dcg_score(hypothesis)/dcg_score(reference)
# Path: torch_mgdcf/metrics/ranking.py
def precision_score(reference, hypothesis):
result = np.sum(hypothesis, dtype=np.float32)/len(hypothesis)
return result
# Path: torch_mgdcf/metrics/ranking.py
def recall_score(reference, hypothesis):
result = np.sum(hypothesis, dtype=np.float32) / len(reference)
return result
# Path: torch_mgdcf/vector_search/vector_search.py
class VectorSearchEngine(object):
def __init__(self, vectors):
super().__init__()
if isinstance(vectors, torch.Tensor):
self.vectors = vectors.detach().cpu().numpy()
else:
self.vectors = np.array(vectors)
self.dim = self.vectors.shape[1]
self.index = faiss.IndexFlatIP(self.dim)
self.index.add(self.vectors)
def search(self, query_vectors, k=10):
query_vectors = np.asarray(query_vectors)
topK_distances, topK_indices = self.index.search(query_vectors, k)
return topK_distances, topK_indices
# Path: torch_mgdcf/evaluation/ranking.py
from tqdm import tqdm
from torch_mgdcf.metrics.ranking import ndcg_score, precision_score, recall_score
from torch_mgdcf.vector_search.vector_search import VectorSearchEngine
import numpy as np
import torch
# coding=utf-8
# The code is from our another project GRecX: https://github.com/maenzhier/grecx_datasets
def score(ground_truth, pred_items, k_list, metrics):
pred_match = [1 if item in ground_truth else 0 for item in pred_items]
max_k = k_list[-1]
if len(ground_truth) > max_k:
ndcg_gold = [1] * max_k
else:
ndcg_gold = [1] * len(ground_truth) + [0] * (max_k - len(ground_truth))
res_score = []
for metric in metrics:
if metric == "ndcg":
score_func = ndcg_score
elif metric == "precision":
score_func = precision_score
elif metric == "recall":
score_func = recall_score
else:
raise Exception("Not Found Metric : {}".format(metric))
for k in k_list:
if metric == "ndcg":
res_score.append(score_func(ndcg_gold[:k], pred_match[:k]))
else:
res_score.append(score_func(ground_truth, pred_match[:k]))
return res_score
def evaluate_mean_global_metrics(user_items_dict, user_mask_items_dict,
user_embedding, item_embedding,
k_list=[10, 20], metrics=["ndcg"]):
| v_search = VectorSearchEngine(item_embedding) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: KyanChen/TTP
# Path: mmseg/utils/typing_utils.py
# Path: opencd/registry.py
MODELS = Registry('model', parent=MMENGINE_MODELS, locations=['opencd.models'])
# Path: opencd/models/data_preprocessor.py
from numbers import Number
from typing import Any, Dict, List, Optional, Sequence, Union
from mmengine.model import BaseDataPreprocessor
from mmseg.utils import SampleList
from opencd.registry import MODELS
import numpy as np
import torch
import torch.nn.functional as F
# Copyright (c) Open-CD. All rights reserved.
def stack_batch(inputs: List[torch.Tensor],
data_samples: Optional[SampleList] = None,
size: Optional[tuple] = None,
size_divisor: Optional[int] = None,
pad_val: Union[int, float] = 0,
seg_pad_val: Union[int, float] = 255) -> torch.Tensor:
"""Stack multiple inputs to form a batch and pad the images and gt_sem_segs
to the max shape use the right bottom padding mode.
Args:
inputs (List[Tensor]): The input multiple tensors. each is a
CHW 3D-tensor.
data_samples (list[:obj:`SegDataSample`]): The list of data samples.
It usually includes information such as `gt_sem_seg`.
size (tuple, optional): Fixed padding size.
size_divisor (int, optional): The divisor of padded size.
pad_val (int, float): The padding value. Defaults to 0
seg_pad_val (int, float): The padding value. Defaults to 255
Returns:
Tensor: The 4D-tensor.
List[:obj:`SegDataSample`]: After the padding of the gt_seg_map.
"""
assert isinstance(inputs, list), \
f'Expected input type to be list, but got {type(inputs)}'
assert len({tensor.ndim for tensor in inputs}) == 1, \
f'Expected the dimensions of all inputs must be the same, ' \
f'but got {[tensor.ndim for tensor in inputs]}'
assert inputs[0].ndim == 3, f'Expected tensor dimension to be 3, ' \
f'but got {inputs[0].ndim}'
assert len({tensor.shape[0] for tensor in inputs}) == 1, \
f'Expected the channels of all inputs must be the same, ' \
f'but got {[tensor.shape[0] for tensor in inputs]}'
# only one of size and size_divisor should be valid
assert (size is not None) ^ (size_divisor is not None), \
'only one of size and size_divisor should be valid'
padded_inputs = []
padded_samples = []
inputs_sizes = [(img.shape[-2], img.shape[-1]) for img in inputs]
max_size = np.stack(inputs_sizes).max(0)
if size_divisor is not None and size_divisor > 1:
# the last two dims are H,W, both subject to divisibility requirement
max_size = (max_size +
(size_divisor - 1)) // size_divisor * size_divisor
for i in range(len(inputs)):
tensor = inputs[i]
if size is not None:
width = max(size[-1] - tensor.shape[-1], 0)
height = max(size[-2] - tensor.shape[-2], 0)
# (padding_left, padding_right, padding_top, padding_bottom)
padding_size = (0, width, 0, height)
elif size_divisor is not None:
width = max(max_size[-1] - tensor.shape[-1], 0)
height = max(max_size[-2] - tensor.shape[-2], 0)
padding_size = (0, width, 0, height)
else:
padding_size = [0, 0, 0, 0]
# pad img
pad_img = F.pad(tensor, padding_size, value=pad_val)
padded_inputs.append(pad_img)
# pad gt_sem_seg
if data_samples is not None:
data_sample = data_samples[i]
gt_sem_seg = data_sample.gt_sem_seg.data
del data_sample.gt_sem_seg.data
data_sample.gt_sem_seg.data = F.pad(
gt_sem_seg, padding_size, value=seg_pad_val)
if 'gt_edge_map' in data_sample:
gt_edge_map = data_sample.gt_edge_map.data
del data_sample.gt_edge_map.data
data_sample.gt_edge_map.data = F.pad(
gt_edge_map, padding_size, value=seg_pad_val)
if 'gt_seg_map_from' in data_sample:
gt_seg_map_from = data_sample.gt_seg_map_from.data
del data_sample.gt_seg_map_from.data
data_sample.gt_seg_map_from.data = F.pad(
gt_seg_map_from, padding_size, value=seg_pad_val)
if 'gt_seg_map_to' in data_sample:
gt_seg_map_to = data_sample.gt_seg_map_to.data
del data_sample.gt_seg_map_to.data
data_sample.gt_seg_map_to.data = F.pad(
gt_seg_map_to, padding_size, value=seg_pad_val)
data_sample.set_metainfo({
'img_shape': tensor.shape[-2:],
'pad_shape': data_sample.gt_sem_seg.shape,
'padding_size': padding_size
})
padded_samples.append(data_sample)
else:
padded_samples.append(
dict(
img_padding_size=padding_size,
pad_shape=pad_img.shape[-2:]))
return torch.stack(padded_inputs, dim=0), padded_samples
| @MODELS.register_module() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: N0rz3/Phunter
# Path: lib/free_lookup.py
async def free(phone_number):
r = await Request("https://free-lookup.net/{}".format(phone_number), headers={'user-agent': random.choice(agent)}).get()
html_body = BeautifulSoup(r.text, "html.parser")
list_info = html_body.findChild("ul", class_="report-summary__list").findAll("div")
info_dict = {
k.text.strip(): info.text.strip() if info.text.strip() else "Not found"
for _, (k, info) in enumerate(zip(list_info[::2], list_info[1::2]))
}
print(f"\n [{GREEN}>{WHITE}] Free-lookup")
for key, value in info_dict.items():
if value != "Not found":
print(f" ├── {key}: {value}")
else:
continue
# Path: lib/spam.py
async def spamcalls(p_n):
print(f"\n [{GREEN}>{WHITE}] Spamcalls")
url = f"https://spamcalls.net/en/number/{p_n}"
r = await Request(url, headers={'user-agent': random.choice(user_agent)}).get()
if r.status_code == 200:
print(f" └── {RED}!{WHITE} Spammer")
else:
print(f" └── {GREEN}>{WHITE} Not spammer")
# Path: lib/lookup.py
import phonenumbers
import json
from phonenumbers import carrier
from .reputation import *
from .free_lookup import free
from .spam import spamcalls
from lib.text import *
async def lookup(phone_number):
print()
parsed = phonenumbers.parse(phone_number)
operator = carrier.name_for_number(parsed, "fr")
line = phonenumbers.number_type(parsed)
if line == phonenumbers.PhoneNumberType.FIXED_LINE:
ligne = f" [{GREEN}>{WHITE}] Line type: Fixed"
elif line == phonenumbers.PhoneNumberType.MOBILE:
ligne = f" [{GREEN}>{WHITE}] Line type: Mobile"
else:
ligne = " [-] Line not found"
possible = phonenumbers.is_possible_number(parsed)
valid = phonenumbers.is_valid_number(parsed)
with open("lib/country.json", "r") as file:
read = json.load(file)
d = 0
countrys = []
for country, code in read.items():
d += 1
if phone_number.startswith(code):
countrys.append(country)
if d == 153:
break
else:
continue
else:
continue
print(f"{WHITE}📞 Phone number: {BLUE}{phone_number}{WHITE}")
if possible == True:
pos = {"possible": "✔️"}
else:
pos = {"possible": "❌"}
if valid == True:
val = {"valid": "✔️"}
else:
val = {"valid": "❌"}
print(f" [{GREEN}>{WHITE}] Possible: {pos['possible']}")
print(f" [{GREEN}>{WHITE}] Valid: {val['valid']}")
print()
if operator != "":
print(f" [{GREEN}>{WHITE}] Operator: {operator}")
else:
print(f" [-] Not Operator")
try:
print(f" [{GREEN}>{WHITE}] Possible location: " + str(countrys).replace("[", "").replace("]", "").replace("'", ""))
except:
print(f" [-] Not location")
print(ligne)
await reputation(phone_number)
| await free(str(phone_number).replace("+", ""))
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: dan-r/HomeAssistant-Ohme
# Path: custom_components/ohme/const.py
DOMAIN = "ohme"
# Path: custom_components/ohme/const.py
DATA_COORDINATORS = "coordinators"
# Path: custom_components/ohme/const.py
COORDINATOR_CHARGESESSIONS = 0
# Path: custom_components/ohme/const.py
COORDINATOR_ADVANCED = 3
# Path: custom_components/ohme/const.py
DATA_CLIENT = "client"
# Path: custom_components/ohme/coordinator.py
class OhmeChargeSessionsCoordinator(DataUpdateCoordinator):
"""Coordinator to pull main charge state and power/current draw."""
def __init__(self, hass):
"""Initialise coordinator."""
super().__init__(
hass,
_LOGGER,
name="Ohme Charge Sessions",
update_interval=timedelta(seconds=30),
)
self._client = hass.data[DOMAIN][DATA_CLIENT]
async def _async_update_data(self):
"""Fetch data from API endpoint."""
try:
return await self._client.async_get_charge_sessions()
except BaseException:
raise UpdateFailed("Error communicating with API")
# Path: custom_components/ohme/coordinator.py
class OhmeAdvancedSettingsCoordinator(DataUpdateCoordinator):
"""Coordinator to pull CT clamp reading."""
def __init__(self, hass):
"""Initialise coordinator."""
super().__init__(
hass,
_LOGGER,
name="Ohme Advanced Settings",
update_interval=timedelta(minutes=1),
)
self._client = hass.data[DOMAIN][DATA_CLIENT]
async def _async_update_data(self):
"""Fetch data from API endpoint."""
try:
return await self._client.async_get_advanced_settings()
except BaseException:
raise UpdateFailed("Error communicating with API")
# Path: custom_components/ohme/utils.py
def charge_graph_in_slot(charge_start, points, skip_format=False):
"""Are we currently in a charge slot?"""
now = int(time())
data = points if skip_format else _format_charge_graph(charge_start, points)
# Loop through every value, skipping the last
for idx in range(0, len(data) - 1):
# This is our current point
if data[idx]["t"] < now and data[idx + 1]["t"] > now:
# If the delta line we are on is steeper than 10,
# we are in a charge slot.
if data[idx + 1]["y"] - data[idx]["y"] > 10:
return True
break
return False
# Path: custom_components/ohme/binary_sensor.py
import logging
from homeassistant.components.binary_sensor import (
BinarySensorDeviceClass,
BinarySensorEntity
)
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import generate_entity_id
from homeassistant.util.dt import (utcnow)
from .const import DOMAIN, DATA_COORDINATORS, COORDINATOR_CHARGESESSIONS, COORDINATOR_ADVANCED, DATA_CLIENT
from .coordinator import OhmeChargeSessionsCoordinator, OhmeAdvancedSettingsCoordinator
from .utils import charge_graph_in_slot
"""Platform for sensor integration."""
from __future__ import annotations
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(
hass: core.HomeAssistant,
config_entry: config_entries.ConfigEntry,
async_add_entities,
):
"""Setup sensors and configure coordinator."""
client = hass.data[DOMAIN][DATA_CLIENT]
| coordinator = hass.data[DOMAIN][DATA_COORDINATORS][COORDINATOR_CHARGESESSIONS] |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Almas-Ali/SpyIP
# Path: spyip/exceptions.py
class TooManyRequests(Exception):
pass
# Path: spyip/exceptions.py
class ConnectionTimeout(Exception):
pass
# Path: spyip/exceptions.py
class StatusError(Exception):
pass
# Path: spyip/models.py
class IPResponse(BaseModel):
"""
Example response from API:
{
"status": "success",
"continent": "Asia",
"continentCode": "AS",
"country": "India",
"countryCode": "IN",
"region": "DL",
"regionName": "National Capital Territory of Delhi",
"city": "New Delhi",
"district": "",
"zip": "110001",
"lat": 28.6139,
"lon": 77.209,
"timezone": "Asia/Kolkata",
"offset": 19800,
"currency": "INR",
"isp": "Google LLC",
"org": "Google LLC",
"as": "AS15169 Google LLC",
"asname": "GOOGLE",
"mobile": false,
"proxy": false,
"hosting": true,
"query": "142.250.193.206",
}
"""
status: str = Field(..., description='Status of the request.')
continent: str = Field(..., description='Continent name.')
continentCode: str = Field(..., description='Continent code.')
country: str = Field(..., description='Country name.')
countryCode: str = Field(..., description='Country code.')
region: str = Field(..., description='Region code.')
regionName: str = Field(..., description='Region name.')
city: str = Field(..., description='City name.')
district: str = Field(..., description='District name.')
zip_: str = Field(..., description='Zip code.')
lat: float = Field(..., description='Latitude.')
lon: float = Field(..., description='Longitude.')
timezone: str = Field(..., description='Timezone.')
offset: int = Field(..., description='Offset.')
currency: str = Field(..., description='Currency.')
isp: str = Field(..., description='ISP name.')
org: str = Field(..., description='Organization name.')
as_: str = Field(..., description='AS number and name.')
asname: str = Field(..., description='AS name.')
mobile: bool = Field(..., description='Mobile status.')
proxy: bool = Field(..., description='Proxy status.')
hosting: bool = Field(..., description='Hosting status.')
query: str = Field(..., description='IP address.')
class Config:
def alias_generator(x):
return x.replace('_', '')
populate_by_name = True
# fields = { # Alias for reserved keywords
# "as_": "as",
# "zip_": "zip",
# }
@field_validator('status')
def check_status(cls, v):
if v != 'success':
raise ValueError('Invalid IP address.')
return v
def json(self, **kwargs) -> str:
return self.model_dump_json(**kwargs)
# Path: spyip/models.py
class DNSResponse(BaseModel):
"""
Example response from API:
"dns": {
"ip": "74.125.73.83",
"geo": "United States - Google"
}
"""
ip: str = Field(..., description='IP address.')
geo: str = Field(..., description='Geo location.')
def json(self, **kwargs) -> str:
return self.model_dump_json(**kwargs)
# Path: spyip/backend.py
from typing import List, Union
from .exceptions import (
TooManyRequests,
ConnectionTimeout,
StatusError,
)
from .models import (
IPResponse,
DNSResponse,
)
import asyncio
import random
import string
import httpx
def get_random_string(length: int = 32) -> str:
"""Generate a random string of fixed length."""
letters = string.ascii_lowercase + string.digits
return ''.join(random.sample(letters, length))
# API endpoints for IP address lookup
trace_me_url = 'http://ip-api.com/json/'
trace_ip_url = 'http://ip-api.com/json/%(query)s'
trace_dns_url = f'http://{get_random_string(32)}.edns.ip-api.com/json/'
trace_ip_batch_url = 'http://ip-api.com/batch'
headers = {
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate',
'Accept-Language': 'en-US,en;q=0.5',
'Connection': 'keep-alive',
'Upgrade-Insecure-Requests': '1',
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
}
def trace_me(
timeout: int = 5,
lang: str = 'en',
| ) -> Union[IPResponse, None]: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: leopedroso45/Stable-Diffusion-ImageGen
# Path: sevsd/process_task.py
def check_cuda_and_clear_cache():
r"""
Clears the CUDA cache if available, otherwise performs garbage collection.
This function is called to manage memory usage, particularly when working with large models or multiple image generations.
"""
if torch.cuda.is_available():
torch.cuda.empty_cache()
else:
gc.collect()
# Path: sevsd/process_task.py
def process_task(job, pipeline, executor, path, parallel_exec=True):
r"""
Processes a single image generation job using the specified pipeline and execution parameters.
This function handles the generation of one or more images based on a given job description. It supports both parallel and sequential execution modes. Generated images are saved to the specified path.
Parameters:
job (dict): A dictionary containing details for the image generation task. It includes 'prompt' and optionally 'negative_prompt'.
pipeline (callable): The Stable Diffusion pipeline callable used for generating images.
executor (dict): A dictionary containing execution parameters such as 'num_of_exec', 'cfg_scale', and 'inference_steps'.
path (str): The directory path where generated images will be saved.
parallel_exec (bool, optional): If True, generates all specified images in parallel. Defaults to True.
The function saves each generated image with a unique timestamp in the specified path and prints the save location. In case of any exceptions, they are caught and printed.
Example:
job = {
"prompt": "A scenic landscape",
"negative_prompt": "blurred image, black and white, watermarked image"
}
executor = {
"num_of_exec": 2,
"cfg_scale": 7,
"inference_steps": 50
}
pipeline = setup_pipeline("CompVis/stable-diffusion-v1-4")
process_task(job, pipeline, executor, "./generated-images", parallel_exec=False)
Note:
This function also handles CUDA cache clearing and garbage collection for memory management.
"""
def call_generate_image():
images = generate_image(job, pipeline, executor, parallel_exec)
if images is not None:
for image in images:
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S%f")
image_path = f"{path}/generated_image_{timestamp}.png"
image.save(image_path)
print(f"[sevsd] - image saved at {image_path}")
else:
print("[sevsd] - image generation failed due to memory constraints.")
check_cuda_and_clear_cache()
try:
path = check_os_path(path)
if job is not None:
if parallel_exec is not True:
num_images = executor.get("num_of_exec", 1)
for _ in range(num_images):
call_generate_image()
else:
call_generate_image()
except Exception as e:
print(f"[sevsd] - exception: {e}")
finally:
check_cuda_and_clear_cache()
# Path: sevsd/process_task.py
def check_os_path(path):
r"""
Checks if the given path exists, and if not, creates the necessary directories.
This function ensures that the output path for saving images is available.
Parameters:
path (str): The directory path to check and create if necessary.
Returns:
str: The verified or created directory path.
"""
if not os.path.exists(path):
os.makedirs(path)
print(f"[sevsd] - created path: {path}")
return path
# Path: tests/test_process_task.py
import unittest
import sys
from unittest.mock import patch, MagicMock
from sevsd.process_task import check_cuda_and_clear_cache, process_task, check_os_path
sys.path.append('../')
class TestProcessTask(unittest.TestCase):
@patch('sevsd.process_task.generate_image')
def test_process_task(self, mock_generate_image):
mock_image = MagicMock()
mock_image.save = MagicMock()
mock_generate_image.return_value = [mock_image]
fake_job = {"prompt": "prompt", "details": (None, 50, 1, 7.5)}
fake_pipeline = MagicMock()
fake_executor = {"num_of_exec": 1, "cfg_scale": 7}
fake_path = "test_path"
| process_task(fake_job, fake_pipeline, fake_executor, fake_path, parallel_exec=True) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Emperor-WS/PyEmber
# Path: ember/autograd/hook.py
class Hook:
"""
Hook class for attaching gradient functions to tensors.
Hooks allow users to attach custom gradient functions to tensors for
monitoring or modifying gradients during backpropagation.
Attributes:
- tensor (Tensor): The target tensor.
- grad_fn (callable): The gradient function to be applied to the tensor.
Methods:
- __init__(self, tensor, grad_fn): Constructor for Hook class.
- __repr__(self): String representation of the Hook instance.
"""
__slots__ = 'tensor', 'grad_fn'
def __init__(self, tensor, grad_fn):
"""
Constructor for the Hook class.
Args:
- tensor (Tensor): The target tensor.
- grad_fn (callable): The gradient function to be applied to the tensor.
"""
self.tensor = tensor
self.grad_fn = grad_fn
def __repr__(self):
"""
String representation of the Hook instance.
Returns:
- str: A string containing information about the tensor and its associated gradient function.
"""
# Extract the class name from the qualified name of the gradient function
grad_name = self.grad_fn.__qualname__.split('.')[0]
return f"Hook(tensor_id={self.tensor.id}, grad_fn={grad_name.upper()})"
# Path: ember/autograd/_utils.py
def numpy_unpad(x, pad_width):
"""
Remove padding from an array.
Args:
- x (numpy.ndarray): Input array.
- pad_width (tuple of ints): Amount of padding on each dimension.
Returns:
- numpy.ndarray: Unpadded array.
"""
slices = []
for pad in pad_width:
end = None if pad[1] == 0 else -pad[1]
slices.append(slice(pad[0], end ))
return x[tuple(slices)]
# Path: ember/autograd/_utils.py
def inv_permutation(permutation):
"""
Compute the inverse of a permutation.
Args:
- permutation (list): List representing a permutation.
Returns:
- list: Inverse permutation.
"""
inverse = [0] * len(permutation)
for original_idx, permuted_idx in enumerate(permutation):
inverse[permuted_idx] = original_idx
return inverse
# Path: ember/autograd/numeric.py
import numpy as np
import ember
from .hook import Hook
from ._utils import numpy_unpad, inv_permutation
def _T(t):
"""
Transpose operation on the input tensor.
Args:
- t: Input tensor.
Returns:
- Tensor: Resultant tensor with the transpose operation applied.
"""
t = ember.to_tensor(t) # Convert the input tensor to a Tensor
data = t.data.T # Transpose operation
requires_grad = t.requires_grad # Set requires_grad based on input tensor
hooks = []
# Register a hook for gradient computation if the input tensor requires it
if requires_grad:
| hooks.append(Hook(t, lambda grad: grad.T)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Hassi34/iot-device-identification
# Path: src/utils/common.py
def read_yaml(path_to_yaml: str) -> dict:
with open(path_to_yaml) as yaml_file:
content = yaml.safe_load(yaml_file)
return content
# Path: src/utils/sys_logging.py
def get_logger(logs_filepath: str):
logger.add(
logs_filepath,
format="{time} | {level} | {name}.{module}:{line} | {message}",
level="DEBUG",
rotation="10 KB",
retention="10 days",
compression="zip",
colorize=True,
enqueue=True,
catch=True,
encoding="utf-8",
)
return logger
# Path: src/utils/common.py
def write_dict_to_yaml(dict_input: dict, yaml_file_path: str):
try:
current_file_data = read_yaml(yaml_file_path)
current_file_data.update(dict_input)
with open(yaml_file_path, "w") as f:
yaml.dump(current_file_data, f)
except (FileNotFoundError , AttributeError):
with open(yaml_file_path, "w") as f:
yaml.dump(dict_input, f)
# Path: src/utils/data_ops.py
def gzip_np_arr(np_array: np.ndarray, filepath: str):
with gzip.GzipFile(filepath, "w") as f:
np.save(file=f, arr=np_array)
# Path: src/utils/data_ops.py
def get_fitted_pipeline(df, columns, KNN_IMPUTER_NEIGHBORS: int = 3):
ct = ColumnTransformer(
transformers=[("input_features", "passthrough", columns)], remainder="drop"
)
imputer = KNNImputer(n_neighbors=KNN_IMPUTER_NEIGHBORS)
scaler = StandardScaler()
pipeline = Pipeline(
steps=[("select_columns", ct), ("imputer", imputer), ("scaler", scaler)]
)
return pipeline.fit(df)
# Path: src/stage_03_preprocess_data.py
import argparse
import joblib
import pandas as pd
from src.utils.common import read_yaml
from src.utils.sys_logging import get_logger
from sklearn.preprocessing import LabelEncoder
from src.utils.common import write_dict_to_yaml
from src.utils.data_ops import gzip_np_arr
from sklearn.model_selection import train_test_split
from src.utils.data_ops import get_fitted_pipeline
from pathlib import Path
STAGE = "Preprocess Data"
def preprocess_data():
complete_df = pd.read_parquet(RAW_DATA_FILE_PATH)
logger.info(
f'The raw data file has been loaded from "{RAW_DATA_FILE_PATH}" with the shape "{complete_df.shape}"'
)
duplicate_rows = complete_df.duplicated().sum()
if duplicate_rows > 0:
logger.warning(
f"Found {duplicate_rows} duplicate rows, removing duplicate rows..."
)
complete_df = complete_df.drop_duplicates(keep="first")
X = complete_df.drop([TARGET_COLUMN_NAME], axis=1)
y = complete_df[TARGET_COLUMN_NAME]
feature_cols = params["input_features_schema"]
feature_cols = list(feature_cols.keys())
logger.info(f"Read {len(feature_cols)} feature columns from params")
data_processing_pipeline = get_fitted_pipeline(
X, feature_cols, KNN_IMPUTER_NEIGHBORS=KNN_IMPUTER_NEIGHBORS
)
Path(DATA_PREPROCESSING_PIPELINE_FILE_PATH).parent.absolute().mkdir(parents=True, exist_ok=True)
joblib.dump(data_processing_pipeline, DATA_PREPROCESSING_PIPELINE_FILE_PATH, compress=1)
logger.info(f"Saved the preprocessing pipeline to {DATA_PREPROCESSING_PIPELINE_FILE_PATH}")
data_processing_pipeline = joblib.load(DATA_PREPROCESSING_PIPELINE_FILE_PATH)
data_processing_pipeline
data_processing_pipeline = joblib.load(DATA_PREPROCESSING_PIPELINE_FILE_PATH)
logger.info(
f'Loaded sklearn data preprocessing pipeline from "{DATA_PREPROCESSING_PIPELINE_FILE_PATH}"'
)
X_transformed = data_processing_pipeline.transform(X)
logger.info(f'Dataframe shape after transformation is "{X_transformed.shape}"')
le = LabelEncoder()
le.fit(y)
labels_mapping_dict = {"labels_mapping": ""}
le_dict = dict(zip(le.transform(le.classes_), le.classes_))
le_dict = {int(k): v for k, v in le_dict.items()}
labels_mapping_dict["labels_mapping"] = le_dict
logger.info(f"Label encoding map has the dictionary: {le_dict}")
write_dict_to_yaml(labels_mapping_dict, parsed_args.params)
logger.info(f'Updated the label encoding map in the file at "{parsed_args.params}"')
| labels_dict = read_yaml(parsed_args.params)["labels_mapping"] |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: see2023/Bert-VITS2-ext
# Path: config.py
class Resample_config:
class Preprocess_text_config:
class Bert_gen_config:
class Emo_gen_config:
class Train_ms_config:
class Webui_config:
class Server_config:
class Translate_config:
class Config:
def __init__(self, in_dir: str, out_dir: str, sampling_rate: int = 44100):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self,
transcription_path: str,
cleaned_path: str,
train_path: str,
val_path: str,
config_path: str,
val_per_lang: int = 5,
max_val_total: int = 10000,
clean: bool = True,
):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self,
config_path: str,
num_processes: int = 2,
device: str = "cuda",
use_multi_device: bool = False,
):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self,
config_path: str,
num_processes: int = 2,
device: str = "cuda",
use_multi_device: bool = False,
):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self,
config_path: str,
env: Dict[str, any],
base: Dict[str, any],
model: str,
num_workers: int,
spec_cache: bool,
keep_ckpts: int,
):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self,
device: str,
model: str,
v_model: str,
config_path: str,
language_identification_library: str,
port: int = 7860,
share: bool = False,
debug: bool = False,
):
def from_dict(cls, dataset_path: str, data: Dict[str, any]):
def __init__(
self, models: List[Dict[str, any]], port: int = 5000, device: str = "cuda"
):
def from_dict(cls, data: Dict[str, any]):
def __init__(self, app_key: str, secret_key: str):
def from_dict(cls, data: Dict[str, any]):
def __init__(self, config_path: str):
# Path: text/japanese.py
def text2sep_kata(text: str) -> (list, list):
parsed = pyopenjtalk.run_frontend(text)
res = []
sep = []
for parts in parsed:
word, yomi = replace_punctuation(parts["string"]), parts["pron"].replace(
"’", ""
)
if yomi:
if re.match(_MARKS, yomi):
if len(word) > 1:
word = [replace_punctuation(i) for i in list(word)]
yomi = word
res += yomi
sep += word
continue
elif word not in rep_map.keys() and word not in rep_map.values():
word = ","
yomi = word
res.append(yomi)
else:
if word in _SYMBOL_TOKENS:
res.append(word)
elif word in ("っ", "ッ"):
res.append("ッ")
elif word in _NO_YOMI_TOKENS:
pass
else:
res.append(word)
sep.append(word)
return sep, [hira2kata(i) for i in res], get_accent(parsed)
# Path: for_deploy/infer_utils.py
import sys
import torch
from transformers import (
AutoModelForMaskedLM,
AutoTokenizer,
DebertaV2Model,
DebertaV2Tokenizer,
ClapModel,
ClapProcessor,
)
from config import config
from text.japanese import text2sep_kata
class BertFeature:
def __init__(self, model_path, language="ZH"):
self.model_path = model_path
self.language = language
self.tokenizer = None
self.model = None
self.device = None
self._prepare()
def _get_device(self, device=config.bert_gen_config.device):
if (
sys.platform == "darwin"
and torch.backends.mps.is_available()
and device == "cpu"
):
device = "mps"
if not device:
device = "cuda"
return device
def _prepare(self):
self.device = self._get_device()
if self.language == "EN":
self.tokenizer = DebertaV2Tokenizer.from_pretrained(self.model_path)
self.model = DebertaV2Model.from_pretrained(self.model_path).to(self.device)
else:
self.tokenizer = AutoTokenizer.from_pretrained(self.model_path)
self.model = AutoModelForMaskedLM.from_pretrained(self.model_path).to(
self.device
)
self.model.eval()
def get_bert_feature(self, text, word2ph):
if self.language == "JP":
| text = "".join(text2sep_kata(text)[0]) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: chinhsuanwu/ifusion-threestudio
# Path: threestudio/models/materials/base.py
class BaseMaterial(BaseModule):
@dataclass
class Config(BaseModule.Config):
pass
cfg: Config
requires_normal: bool = False
requires_tangent: bool = False
def configure(self):
pass
def forward(self, *args, **kwargs) -> Float[Tensor, "*B 3"]:
raise NotImplementedError
def export(self, *args, **kwargs) -> Dict[str, Any]:
return {}
# Path: threestudio/models/networks.py
def get_encoding(n_input_dims: int, config) -> nn.Module:
# input suppose to be range [0, 1]
encoding: nn.Module
if config.otype == "ProgressiveBandFrequency":
encoding = ProgressiveBandFrequency(n_input_dims, config_to_primitive(config))
elif config.otype == "ProgressiveBandHashGrid":
encoding = ProgressiveBandHashGrid(n_input_dims, config_to_primitive(config))
elif config.otype == "HashGridSpatialTime":
encoding = TCNNEncodingSpatialTime(n_input_dims, config) # 4D-fy encoding
else:
encoding = TCNNEncoding(n_input_dims, config_to_primitive(config))
encoding = CompositeEncoding(
encoding,
include_xyz=config.get("include_xyz", False),
xyz_scale=2.0,
xyz_offset=-1.0,
) # FIXME: hard coded
return encoding
# Path: threestudio/models/networks.py
def get_mlp(n_input_dims, n_output_dims, config) -> nn.Module:
network: nn.Module
if config.otype == "VanillaMLP":
network = VanillaMLP(n_input_dims, n_output_dims, config_to_primitive(config))
elif config.otype == "SphereInitVanillaMLP":
network = SphereInitVanillaMLP(
n_input_dims, n_output_dims, config_to_primitive(config)
)
else:
assert (
config.get("sphere_init", False) is False
), "sphere_init=True only supported by VanillaMLP"
network = TCNNNetwork(n_input_dims, n_output_dims, config_to_primitive(config))
return network
# Path: threestudio/utils/ops.py
def dot(x, y):
return torch.sum(x * y, -1, keepdim=True)
# Path: threestudio/utils/ops.py
def get_activation(name) -> Callable:
if name is None:
return lambda x: x
name = name.lower()
if name == "none":
return lambda x: x
elif name == "lin2srgb":
return lambda x: torch.where(
x > 0.0031308,
torch.pow(torch.clamp(x, min=0.0031308), 1.0 / 2.4) * 1.055 - 0.055,
12.92 * x,
).clamp(0.0, 1.0)
elif name == "exp":
return lambda x: torch.exp(x)
elif name == "shifted_exp":
return lambda x: torch.exp(x - 1.0)
elif name == "trunc_exp":
return trunc_exp
elif name == "shifted_trunc_exp":
return lambda x: trunc_exp(x - 1.0)
elif name == "sigmoid":
return lambda x: torch.sigmoid(x)
elif name == "tanh":
return lambda x: torch.tanh(x)
elif name == "shifted_softplus":
return lambda x: F.softplus(x - 1.0)
elif name == "scale_-11_01":
return lambda x: x * 0.5 + 0.5
else:
try:
return getattr(F, name)
except AttributeError:
raise ValueError(f"Unknown activation function: {name}")
# Path: threestudio/models/materials/no_material.py
import random
import torch
import torch.nn as nn
import torch.nn.functional as F
import threestudio
from dataclasses import dataclass, field
from threestudio.models.materials.base import BaseMaterial
from threestudio.models.networks import get_encoding, get_mlp
from threestudio.utils.ops import dot, get_activation
from threestudio.utils.typing import *
@threestudio.register("no-material")
class NoMaterial(BaseMaterial):
@dataclass
class Config(BaseMaterial.Config):
n_output_dims: int = 3
color_activation: str = "sigmoid"
input_feature_dims: Optional[int] = None
mlp_network_config: Optional[dict] = None
requires_normal: bool = False
cfg: Config
def configure(self) -> None:
self.use_network = False
if (
self.cfg.input_feature_dims is not None
and self.cfg.mlp_network_config is not None
):
self.network = get_mlp(
self.cfg.input_feature_dims,
self.cfg.n_output_dims,
self.cfg.mlp_network_config,
)
self.use_network = True
self.requires_normal = self.cfg.requires_normal
def forward(
self, features: Float[Tensor, "B ... Nf"], **kwargs
) -> Float[Tensor, "B ... Nc"]:
if not self.use_network:
assert (
features.shape[-1] == self.cfg.n_output_dims
), f"Expected {self.cfg.n_output_dims} output dims, only got {features.shape[-1]} dims input."
| color = get_activation(self.cfg.color_activation)(features) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: jasursadikov/mud
# Path: utils.py
TEXT = {
'white': '\033[37m',
'gray': '\033[90m',
'black': '\033[30m',
'red': '\033[31m',
'green': '\033[32m',
'yellow': '\033[33m',
'blue': '\033[34m',
'magenta': '\033[35m',
'cyan': '\033[36m',
'bright_white': '\033[97m',
'bright_red': '\033[91m',
'bright_green': '\033[92m',
'bright_yellow': '\033[93m',
'bright_blue': '\033[94m',
'bright_magenta': '\033[95m',
'bright_cyan': '\033[96m',
}
# Path: utils.py
BACK = {
'white': '\033[47m',
'medium_gray': '\033[100m',
'black': '\033[40m',
'red': '\033[41m',
'green': '\033[42m',
'yellow': '\033[43m',
'blue': '\033[44m',
'magenta': '\033[45m',
'cyan': '\033[46m',
'bright_white': '\033[107m',
'bright_red': '\033[101m',
'bright_green': '\033[102m',
'bright_yellow': '\033[103m',
'bright_blue': '\033[104m',
'bright_magenta': '\033[105m',
'bright_cyan': '\033[106m',
}
# Path: utils.py
RESET = '\033[0m'
# Path: utils.py
STYLES = {
'bold': '\033[1m',
'dim': '\033[2m',
'italic': '\033[3m',
'underline': '\033[4m',
'blink': '\033[5m',
}
# Path: utils.py
END_STYLES = {
'bold': '\033[22m',
'dim': '\033[22m',
'italic': '\033[23m',
'underline': '\033[24m',
'blink': '\033[25m',
}
# Path: utils.py
def glyph(key: str) -> str:
return GLYPHS[key][0] if settings.mud_settings['nerd_fonts'] else GLYPHS[key][1]
# Path: commands.py
import utils
import asyncio
import subprocess
from utils import TEXT, BACK, RESET, STYLES, END_STYLES, glyph
from typing import List, Dict
from collections import Counter
from prettytable import PrettyTable, PLAIN_COLUMNS
class Commands:
def __init__(self, repos):
self.repos = repos
self.label_color_cache = {}
self.current_color_index = 0
# `mud status` command implementation
def status(self, repos: Dict[str, List[str]]) -> None:
table = self._get_table()
for path, tags in repos.items():
formatted_path = self._get_formatted_path(path)
branch = self._get_branch_status(path)
author = self._get_authors_name(path)
commit = self._get_commit_message(path, 30)
colored_labels = self._get_formatted_labels(tags)
# Sync with origin status
ahead_behind_cmd = subprocess.run(['git', 'rev-list', '--left-right', '--count', 'HEAD...@{upstream}'],
text=True, cwd=path, capture_output=True)
stdout = ahead_behind_cmd.stdout.strip().split()
if len(stdout) >= 2:
ahead, behind = stdout[0], stdout[1]
origin_sync = ''
if ahead and ahead != '0':
| origin_sync += f'{TEXT["bright_green"]}{glyph("ahead")} {ahead}{RESET}' |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Q-MM/PureMM
# Path: model/multimodal_encoder/builder.py
def build_vision_tower(vision_tower_cfg, **kwargs):
vision_tower = getattr(vision_tower_cfg, 'mm_vision_tower', getattr(vision_tower_cfg, 'vision_tower', None))
is_absolute_path_exists = os.path.exists(vision_tower)
if is_absolute_path_exists or vision_tower.startswith("openai") or vision_tower.startswith("laion"):
return CLIPVisionTower(vision_tower, args=vision_tower_cfg, **kwargs)
raise ValueError(f'Unknown vision tower: {vision_tower}')
# Path: model/multimodal_projector/builder.py
def build_vision_projector(config, delay_load=False, **kwargs):
projector_type = getattr(config, 'mm_projector_type', 'linear')
if projector_type == 'linear':
return nn.Linear(config.mm_hidden_size, config.hidden_size)
mlp_gelu_match = re.match(r'^mlp(\d+)x_gelu$', projector_type)
if mlp_gelu_match:
mlp_depth = int(mlp_gelu_match.group(1))
modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]
for _ in range(1, mlp_depth):
modules.append(nn.GELU())
modules.append(nn.Linear(config.hidden_size, config.hidden_size))
return nn.Sequential(*modules)
larger_mlp_gelu_match = re.match(r'^larger_mlp(\d+)x_gelu$', projector_type)
if larger_mlp_gelu_match:
mlp_depth = int(mlp_gelu_match.group(1))
modules = [nn.Linear(config.mm_hidden_size, config.mm_hidden_size)]
for _ in range(1, mlp_depth-1):
modules.append(nn.GELU())
modules.append(nn.Linear(config.mm_hidden_size, config.mm_hidden_size))
modules.append(nn.Linear(config.mm_hidden_size, config.hidden_size))
return nn.Sequential(*modules)
if projector_type == 'identity':
return IdentityMap()
raise ValueError(f'Unknown projector type: {projector_type}')
# Path: model/PureMM_arch.py
from abc import ABC, abstractmethod
from .multimodal_encoder.builder import build_vision_tower
from .multimodal_projector.builder import build_vision_projector
import torch
import torch.nn as nn
# Copyright 2023 Haotian Liu
#
# 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 writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
IGNORE_INDEX = -100
IMAGE_TOKEN_INDEX = -200
DEFAULT_IMAGE_TOKEN = "<image>"
DEFAULT_IMAGE_PATCH_TOKEN = "<im_patch>"
DEFAULT_IM_START_TOKEN = "<im_start>"
DEFAULT_IM_END_TOKEN = "<im_end>"
def rank0_print(rank, *args):
if rank == 0:
print(*args)
class PureMMMetaModel:
def __init__(self, config):
super(PureMMMetaModel, self).__init__(config)
if hasattr(config, "mm_vision_tower"):
self.vision_tower = build_vision_tower(config, delay_load=True)
# self.mm_projector = nn.Linear(config.mm_hidden_size, config.hidden_size)
| self.mm_projector = build_vision_projector(config) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Ananya2001-an/spotify-py-sdk
# Path: spotify_py_sdk/spotify_api.py
class SpotifyApi:
"""Create an api instance and call the various endpoint methods.
:param client_id: Client_ID for your app
:type client_id: str
:param client_secret: Client_Secret for your app
:type client_secret: str
:param config: pass :class:`SdkConfig` instance, defaults to None
:type config: :class:`SdkConfig`, optional
"""
_root_url: str = "https://api.spotify.com/v1/"
def __init__(self, client_id: str, client_secret: str, config: Optional[SdkConfig] = None):
"""Constructor method
"""
self.access_token_manager: AccessTokenManager = AccessTokenManager(client_id, client_secret)
self.sdk_config: Optional[SdkConfig] = config
self.albums: Albums = Albums(self)
self.artists: Artists = Artists(self)
self.audiobooks: Audiobooks = Audiobooks(self)
self.browse: Browse = Browse(self)
self.chapters: Chapters = Chapters(self)
self.episodes: Episodes = Episodes(self)
self.recommendations: Recommendations = Recommendations(self)
self.markets: Markets = Markets(self)
# self.player: Player = Player(self) # need different auth strategy; yet to be implemented
self.playlists: Playlists = Playlists(self)
self.shows: Shows = Shows(self)
self.tracks: Tracks = Tracks(self)
self.users: Users = Users(self)
self.search: Search = Search(self)
# self.current_user: CurrentUser = CurrentUser(self) # need different auth strategy; yet to be implemented
@classmethod
def fetch_results(cls, url: str, opts: dict):
"""Fetch results by making a request to the given URL
"""
try:
result = requests.request(method=opts["method"], url=url, headers=opts["headers"], data=opts["body"])
return result.json()
except HTTPError as e:
raise f"Failed to fetch result! {e}"
def make_request(self, method: Literal["GET", "POST", "PUT", "DELETE"], url: str, body: Optional[any] = None,
content_type: Optional[str] = None):
"""Get access token and make necessary request call to the api endpoint
"""
try:
access_token = self.access_token_manager.get_access_token()
except HTTPError as e:
raise "Access Token not available! Authenticate again."
full_url = SpotifyApi._root_url + url
opts = {
"method": method,
"headers": {
"Authorization": f"Bearer {access_token}",
"Content-Type": content_type if content_type else "application/json"
},
"body": json.dumps(body) if body and type(body) is not str else body
}
try:
if self.sdk_config:
if self.sdk_config.before_request:
self.sdk_config.before_request(full_url, opts)
if self.sdk_config.fetch:
result = self.sdk_config.fetch(full_url, opts)
else:
result = SpotifyApi.fetch_results(full_url, opts)
if self.sdk_config.after_request:
self.sdk_config.after_request(full_url, opts, result)
return result
return SpotifyApi.fetch_results(full_url, opts)
except (HTTPError, ValueError, InterruptedError) as e:
raise e
# handled = self.sdk_config.error_handler.handleErrors(e)
# if not handled:
# raise Exception("Failed to make request! Try again.")
# Path: spotify_py_sdk/endpoints/recommendations.py
class RecommendationsRequestRequiredArguments:
def __init__(self, seed_artists: Optional[list[str]] = None, seed_genres: Optional[list[str]] = None, seed_tracks: Optional[list[str]] = None):
self.seed_artists = seed_artists
self.seed_genres = seed_genres
self.seed_tracks = seed_tracks
# Path: tests/endpoints/test_recommendations.py
import json
import pytest
import os
from spotify_py_sdk import SpotifyApi
from spotify_py_sdk.endpoints.recommendations import RecommendationsRequestRequiredArguments
from dotenv import load_dotenv
load_dotenv()
@pytest.fixture
def api():
| return SpotifyApi(os.getenv("CLIENT_ID"), os.getenv("CLIENT_SECRET")) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: kyleliang919/Optimizer-Zoo
# Path: optimizer_zoo/Trainer/async_trainer.py
class AsyncTrainer(Trainer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.accelerator.sync_gradients = None
def training_step(self, model, inputs):
# make sure the gradient is not automatically synced
with model.no_sync():
model.train()
inputs = self._prepare_inputs(inputs)
if is_sagemaker_mp_enabled():
loss_mb = smp_forward_backward(model, inputs, self.args.gradient_accumulation_steps)
return loss_mb.reduce_mean().detach().to(self.args.device)
with self.compute_loss_context_manager():
loss = self.compute_loss(model, inputs)
if self.args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if self.use_apex:
with amp.scale_loss(loss, self.optimizer) as scaled_loss:
scaled_loss.backward()
else:
self.accelerator.backward(loss)
return loss.detach() / self.args.gradient_accumulation_steps
# Path: optimizer_zoo/Trainer/async_trainer.py
class AsyncSFTTrainer(SFTTrainer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def training_step(self, model, inputs):
# make sure the gradient is not automatically synced
with model.no_sync():
model.train()
inputs = self._prepare_inputs(inputs)
if is_sagemaker_mp_enabled():
loss_mb = smp_forward_backward(model, inputs, self.args.gradient_accumulation_steps)
return loss_mb.reduce_mean().detach().to(self.args.device)
with self.compute_loss_context_manager():
loss = self.compute_loss(model, inputs)
if self.args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if self.use_apex:
with amp.scale_loss(loss, self.optimizer) as scaled_loss:
scaled_loss.backward()
else:
self.accelerator.backward(loss)
return loss.detach() / self.args.gradient_accumulation_steps
# Path: optimizer_zoo/Trainer/async_trainer.py
class AsyncDPOTrainer(DPOTrainer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
def training_step(self, model, inputs):
# make sure the gradient is not automatically synced
with model.no_sync():
model.train()
inputs = self._prepare_inputs(inputs)
if is_sagemaker_mp_enabled():
loss_mb = smp_forward_backward(model, inputs, self.args.gradient_accumulation_steps)
return loss_mb.reduce_mean().detach().to(self.args.device)
with self.compute_loss_context_manager():
loss = self.compute_loss(model, inputs)
if self.args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if self.use_apex:
with amp.scale_loss(loss, self.optimizer) as scaled_loss:
scaled_loss.backward()
else:
self.accelerator.backward(loss)
return loss.detach() / self.args.gradient_accumulation_steps
# Path: optimizer_zoo/Trainer/async_trainer.py
class AsyncSeq2SeqTrainer(Seq2SeqTrainer):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.accelerator.sync_gradients = None
def training_step(self, model, inputs):
# make sure the gradient is not automatically synced
with model.no_sync():
model.train()
inputs = self._prepare_inputs(inputs)
if is_sagemaker_mp_enabled():
loss_mb = smp_forward_backward(model, inputs, self.args.gradient_accumulation_steps)
return loss_mb.reduce_mean().detach().to(self.args.device)
with self.compute_loss_context_manager():
loss = self.compute_loss(model, inputs)
if self.args.n_gpu > 1:
loss = loss.mean() # mean() to average on multi-gpu parallel training
if self.use_apex:
with amp.scale_loss(loss, self.optimizer) as scaled_loss:
scaled_loss.backward()
else:
self.accelerator.backward(loss)
return loss.detach() / self.args.gradient_accumulation_steps
# Path: optimizer_zoo/Trainer/utils.py
from transformers import Trainer, Seq2SeqTrainer
from trl import SFTTrainer, DPOTrainer
from .async_trainer import AsyncTrainer, AsyncSFTTrainer, AsyncDPOTrainer, AsyncSeq2SeqTrainer
def create_trainer(training_args):
if training_args.task == "pretraining":
return AsyncTrainer if training_args.async_grad else Trainer
elif training_args.task == "sft":
return AsyncSFTTrainer if training_args.async_grad else SFTTrainer
elif training_args.task == "dpo":
return AsyncDPOTrainer if training_args.async_grad else DPOTrainer
elif training_args.task == "seq2seq":
| return AsyncSeq2SeqTrainer if training_args.async_grad else Seq2SeqTrainer |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: giaminhgist/3D-DAM
# Path: lib/model/attention_block.py
class SpatialAttention3D(nn.Module):
def __init__(self, out_channel=64, kernel_size=3, stride=1, padding=1):
super(SpatialAttention3D, self).__init__()
self.conv = nn.Conv3d(2, out_channel,
kernel_size=kernel_size, stride=stride, padding=padding, bias=False)
self.sigmoid = nn.Sigmoid()
def forward(self, x):
residual = x
avg_out = torch.mean(x, dim=1, keepdim=True)
max_out, _ = torch.max(x, dim=1, keepdim=True)
x = torch.cat([avg_out, max_out], dim=1)
x = self.conv(x)
x = self.sigmoid(x)
out = x * residual
return out
# Path: lib/model/attention_block.py
class ChannelAttention3D(nn.Module):
def __init__(self, in_planes=64, ratio=8):
super(ChannelAttention3D, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool3d(1)
self.max_pool = nn.AdaptiveMaxPool3d(1)
self.fc = nn.Sequential(nn.Conv3d(in_planes, in_planes // ratio, 1, bias=False),
nn.ReLU(),
nn.Conv3d(in_planes // ratio, in_planes, 1, bias=False))
self.sigmoid = nn.Sigmoid()
def forward(self, x):
residual = x
avg_out = self.fc(self.avg_pool(x))
max_out = self.fc(self.max_pool(x))
out = avg_out + max_out
return self.sigmoid(out) * residual
# Path: lib/model/attention_block.py
class residual_block(nn.Module):
def __init__(self, channel_size=64):
super(residual_block, self).__init__()
self.conv = nn.Conv3d(channel_size, channel_size, kernel_size=3, padding=1)
self.relu = nn.ReLU()
self.bn = nn.BatchNorm3d(channel_size)
def forward(self, x):
residual = x
y = self.conv(x)
y = self.bn(y)
y = self.relu(y)
out = y + residual
return out
# Path: lib/model/DuoAttention.py
import numpy as np
import torch
from torch import nn
from lib.model.attention_block import SpatialAttention3D, ChannelAttention3D, residual_block
class DAM(nn.Module):
def __init__(self, channels=64):
super(DAM, self).__init__()
self.sa = SpatialAttention3D(out_channel=channels)
self.ca = ChannelAttention3D(in_planes=channels)
def forward(self, x):
residual = x
out = self.ca(x)
out = self.sa(out)
out = out + residual
return out
class Duo_Attention(nn.Module):
def __init__(
self, input_size=(1, 169, 208, 179), num_classes=3, dropout=0
):
super().__init__()
self.conv = nn.Sequential(
nn.Conv3d(input_size[0], 8, 3, padding=1),
nn.BatchNorm3d(8),
nn.ReLU(),
# nn.MaxPool3d(2, 2),
nn.Conv3d(8, 16, 3, padding=1, stride=2),
nn.BatchNorm3d(16),
nn.ReLU(),
| residual_block(channel_size=16), |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: itsluminous/EasyEncryption
# Path: core.py
def generate_key():
"""Generate a Fernet key."""
return Fernet.generate_key()
# Path: core.py
def encrypt_message(message, key):
"""Encrypt a message using the provided key."""
fernet = Fernet(key)
encrypted = fernet.encrypt(message.encode())
return encrypted
# Path: core.py
def decrypt_message(encrypted_message, key):
"""Decrypt an encrypted message using the provided key."""
fernet = Fernet(key)
decrypted = fernet.decrypt(encrypted_message).decode()
return decrypted
# Path: core.py
def encrypt_file(file_path, key):
"""Encrypt a file using the provided key."""
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
encrypted_content = encrypt_message(content, key)
with open(file_path + '.enc', 'wb') as encrypted_file:
encrypted_file.write(encrypted_content)
print(f"\nFile '{file_path}' encrypted successfully.")
except FileNotFoundError:
print("\nFile not found.")
# Path: core.py
def decrypt_file(file_path, key):
"""Decrypt an encrypted file using the provided key."""
try:
with open(file_path, 'rb', encoding='utf-8') as file:
encrypted_content = file.read()
decrypted_content = decrypt_message(encrypted_content, key)
decrypted_file_path = file_path[:-4] # Remove the '.enc' extension
with open(decrypted_file_path, 'w', encoding='utf-8') as decrypted_file:
decrypted_file.write(decrypted_content)
print(f"\nFile '{file_path}' decrypted successfully.")
except FileNotFoundError:
print("\nFile not found.")
except ValueError:
print("\nInvalid decryption key or file content.")
# Path: script.py
from core import generate_key, encrypt_message, decrypt_message, encrypt_file, decrypt_file
"""
Script providing a user interface for encryption and decryption operations.
"""
def generate_new_key():
"""
Generate a new encryption key.
Returns:
- bytes: New encryption key.
"""
key = generate_key()
print(f"\nGenerated Key: {key.decode()}")
return key
def enter_user_key():
"""
Prompt user to enter a key.
Returns:
- bytes: User-entered key.
"""
print("\nEnter the key:")
return input().encode()
def encrypt_user_message(key):
"""
Encrypt a user-entered message.
Parameters:
- key (bytes): Encryption key.
"""
if key is None:
print("\nPlease generate or enter a key first.")
else:
print("\nEnter a message to encrypt (press Enter twice to finish):")
lines = []
while True:
line = input()
if not line:
break
lines.append(line)
user_input = '\n'.join(lines)
encrypted_message = encrypt_message(user_input, key)
print(f"\nEncrypted message: {encrypted_message}")
def decrypt_user_message(key):
"""
Decrypt a user-entered message.
Parameters:
- key (bytes): Decryption key.
"""
if key is None:
print("\nPlease generate or enter a key first.")
else:
print("\nEnter the encrypted message (press Enter twice to finish):")
lines = []
while True:
line = input()
if not line:
break
lines.append(line)
encrypted_input = '\n'.join(lines)
| decrypted_message = decrypt_message(encrypted_input.encode(), key) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: gardenifi/server
# Path: app/main_app.py
INVALID_DATA = "Invalid data: Unable to process the provided data"
class GlobalVars:
class WifiData(BaseModel):
class ValveData(BaseModel):
class BleData(BaseModel):
def __init__(self):
def refresh_set(self):
def refresh_set(self, value):
async def index():
async def resource_not_found(request: Request, exc: HTTPException):
async def read_ble_data(page: int = None):
async def write_ble_data(data: BleData):
async def discover_wifi(chunked: int = None, page: int = None):
async def save_wifi(data: WifiData):
async def turn(data: ValveData):
async def check_mqtt():
def web_server():
def setup_gpio():
def parse_arguments():
def main():
# Path: app/main_app.py
@app.exception_handler(404)
async def resource_not_found(request: Request, exc: HTTPException):
"""Not found error."""
logger.error(f"Request: {request}")
return JSONResponse(status_code=404, content={"detail": str(exc.detail)})
# Path: tests/api/resource_not_found_test.py
import json
import pytest
from fastapi.testclient import TestClient
from fastapi import HTTPException, Request
from fastapi.responses import JSONResponse
from app.main_app import app
from app.main_app import resource_not_found
"""MIT License
Copyright (c) 2023, Marios Karagiannopoulos
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
**Attribution Requirement:**
When using or distributing the software, an attribution to Marios Karagiannopoulos must be included.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
"""
client = TestClient(app)
scope = {"type": "http", "http_version": "1.1", "method": "GET", "path": "/"}
@pytest.fixture(scope="function")
async def request_obj():
"""Request object creation fixture"""
return Request(scope)
class TestResourceNotFound:
"""
Test class for the 'resource_not_found' error handler function.
"""
@pytest.mark.asyncio
async def test_returns_json_response_with_status_code_404_and_detail_of_httpexception(self, obj=request_obj):
"""
Test for returning a JSONResponse object with status code 404 and the detail of the HTTPException passed as an argument.
"""
exc = HTTPException(status_code=404, detail="Not found")
| response = await resource_not_found(obj, exc) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: xiaoye0x0/pfgo_tg_bot
# Path: utils/task/model.py
class Task(metaclass=SingletonMeta):
def __init__(self, args) -> None:
self.conf_file = args.config
self.bot_token: str = ""
self.pfgo_url: str = ""
self.username: str = ""
self.password: str = ""
self.hide: list = []
self.webhook_url = ""
self.webhook_port = ""
self.running_host = ""
self.running_port = 0
self._init_conf()
def _init_conf(self):
config = configparser.ConfigParser()
config.read(self.conf_file)
self.bot_token = config.get("bot", "token")
self.pfgo_url = config.get("pfgo", "url")
self.username = config.get("pfgo", "username")
self.password = config.get("pfgo", "password")
self.hide += config.get("pfgo", "hide").split(",")
self.webhook_url = config.get("webhook", "webhook_url")
self.webhook_port = config.get("webhook", "webhook_port")
self.running_host = config.get("webhook", "running_host")
self.running_port = int(config.get("webhook", "running_port"))
# Path: utils/log.py
class Logmanager(metaclass=SingletonMeta):
log_list = []
log_list_lock = threading.Lock()
path = "./"
def __init__(self, path: str) -> None:
Logmanager.path = path
@classmethod
def create_logger(cls, name=None):
if name is None:
name = "default"
logger = logging.getLogger(name)
if name not in cls.log_list:
with Logmanager.log_list_lock:
if name not in cls.log_list:
cls.log_list.append(name)
logger.setLevel(logging.INFO)
logfile = f"{Logmanager.path}/log.log"
fh = RotatingFileHandler(
logfile,
mode="a",
maxBytes=1024 * 1024 * 10,
backupCount=2,
encoding="utf-8",
)
formatter = logging.Formatter(
"[%(name)s] [%(asctime)s] [%(levelname)s] %(message)s",
"%Y%m%d-%H:%M:%S",
)
fh.setFormatter(formatter)
logger.addHandler(fh)
ch = logging.StreamHandler()
ch.setFormatter(formatter)
logger.addHandler(ch)
fh.close()
ch.close()
return logger
# Path: utils/task/set_args.py
import os
import argparse
from .model import Task
from ..log import Logmanager
def is_file_exists(file_path) -> bool:
r = os.path.exists(file_path)
if not r:
LOGGER.error(f"文件{file_path}不存在")
return r
def create_folder_if_not_exists(folder_path):
if not folder_path:
return
if not os.path.exists(folder_path):
os.makedirs(folder_path)
def parse_command_line_args():
"""
-c --config: 配置文件
--log: 日志存放位置
"""
parser = argparse.ArgumentParser(description="运行参数")
parser.add_argument("--config", "-c", type=str, default="./config.ini", help="配置文件")
parser.add_argument("--log", type=str, default="./", help="日志存放文件夹的位置,默认放到当前路径")
args = parser.parse_args()
# 初始化日志模块
global LOGGER
create_folder_if_not_exists(args.log)
| Logmanager(args.log) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: shibing624/chatgpt-webui
# Path: src/config.py
def retrieve_openai_api(api_key=None):
def retrieve_proxy(proxy=None):
def update_doc_config(two_column_pdf):
# Path: src/presets.py
OPENAI_API_BASE = "https://api.openai.com/v1"
# Path: src/utils.py
def excel_to_string(file_path):
# 读取Excel文件中的所有工作表
excel_file = pd.read_excel(file_path, engine="openpyxl", sheet_name=None)
# 初始化结果字符串
result = []
# 遍历每一个工作表
for sheet_name, sheet_data in excel_file.items():
# 处理当前工作表并添加到结果字符串
result += sheet_to_string(sheet_data, sheet_name=sheet_name)
return result
# Path: src/utils.py
def get_files_hash(file_src=None, file_paths=None):
if file_src:
file_paths = [x.name for x in file_src]
file_paths.sort(key=lambda x: os.path.basename(x))
md5_hash = hashlib.md5()
for file_path in file_paths:
with open(file_path, "rb") as f:
while chunk := f.read(8192):
md5_hash.update(chunk)
return md5_hash.hexdigest()
# Path: src/utils.py
def load_pkl(file_path):
with open(file_path, 'rb') as f:
data = pickle.load(f)
return data
# Path: src/utils.py
def save_pkl(data, file_path):
with open(file_path, 'wb') as f:
pickle.dump(data, f)
# Path: src/index_func.py
import os
import re
import PyPDF2
from typing import List, Optional, Any
from langchain.schema import Document
from langchain.text_splitter import RecursiveCharacterTextSplitter
from loguru import logger
from tqdm import tqdm
from src.config import local_embedding, retrieve_proxy, chunk_overlap, chunk_size, hf_emb_model_name
from src.presets import OPENAI_API_BASE
from src.utils import excel_to_string, get_files_hash, load_pkl, save_pkl
from src.pdf_func import parse_pdf
from src.config import advance_docs
from langchain.document_loaders import UnstructuredWordDocumentLoader
from langchain.document_loaders import UnstructuredPowerPointLoader
from langchain.document_loaders import UnstructuredEPubLoader
from langchain.document_loaders import TextLoader
from langchain.vectorstores import FAISS
from langchain.embeddings.huggingface import HuggingFaceEmbeddings
from langchain.embeddings import OpenAIEmbeddings
pwd_path = os.path.abspath(os.path.dirname(__file__))
class ChineseRecursiveTextSplitter(RecursiveCharacterTextSplitter):
"""Recursive text splitter for Chinese text.
copy from: https://github.com/chatchat-space/Langchain-Chatchat/tree/master
"""
def __init__(
self,
separators: Optional[List[str]] = None,
keep_separator: bool = True,
is_separator_regex: bool = True,
**kwargs: Any,
) -> None:
"""Create a new TextSplitter."""
super().__init__(keep_separator=keep_separator, **kwargs)
self._separators = separators or [
"\n\n",
"\n",
"。|！|？",
"\.\s|\!\s|\?\s",
"；|;\s",
"，|,\s"
]
self._is_separator_regex = is_separator_regex
@staticmethod
def _split_text_with_regex_from_end(
text: str, separator: str, keep_separator: bool
) -> List[str]:
# Now that we have the separator, split the text
if separator:
if keep_separator:
# The parentheses in the pattern keep the delimiters in the result.
_splits = re.split(f"({separator})", text)
splits = ["".join(i) for i in zip(_splits[0::2], _splits[1::2])]
if len(_splits) % 2 == 1:
splits += _splits[-1:]
else:
splits = re.split(separator, text)
else:
splits = list(text)
return [s for s in splits if s != ""]
def _split_text(self, text: str, separators: List[str]) -> List[str]:
"""Split incoming text and return chunks."""
final_chunks = []
# Get appropriate separator to use
separator = separators[-1]
new_separators = []
for i, _s in enumerate(separators):
_separator = _s if self._is_separator_regex else re.escape(_s)
if _s == "":
separator = _s
break
if re.search(_separator, text):
separator = _s
new_separators = separators[i + 1:]
break
_separator = separator if self._is_separator_regex else re.escape(separator)
splits = self._split_text_with_regex_from_end(text, _separator, self._keep_separator)
# Now go merging things, recursively splitting longer texts.
_good_splits = []
_separator = "" if self._keep_separator else separator
for s in splits:
if self._length_function(s) < self._chunk_size:
_good_splits.append(s)
else:
if _good_splits:
merged_text = self._merge_splits(_good_splits, _separator)
final_chunks.extend(merged_text)
_good_splits = []
if not new_separators:
final_chunks.append(s)
else:
other_info = self._split_text(s, new_separators)
final_chunks.extend(other_info)
if _good_splits:
merged_text = self._merge_splits(_good_splits, _separator)
final_chunks.extend(merged_text)
return [re.sub(r"\n{2,}", "\n", chunk.strip()) for chunk in final_chunks if chunk.strip() != ""]
def get_documents(file_paths):
| text_splitter = ChineseRecursiveTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ConnectAI-E/GitMaya
# Path: server/tasks/lark/base.py
def get_bot_by_application_id(app_id):
application = (
db.session.query(IMApplication)
.filter(
or_(
IMApplication.app_id == app_id,
IMApplication.id == app_id,
)
)
.first()
)
if application:
return (
Bot(
app_id=application.app_id,
app_secret=application.app_secret,
),
application,
)
return None, None
# Path: server/tasks/lark/base.py
def get_git_object_by_message_id(message_id):
"""
根据message_id区分Repo、Issue、PullRequest对象
参数：
message_id：消息ID
返回值：
repo：Repo对象，如果存在
issue：Issue对象，如果存在
pr：PullRequest对象，如果存在
"""
issue = (
db.session.query(Issue)
.filter(
Issue.message_id == message_id,
)
.first()
)
if issue:
return None, issue, None
pr = (
db.session.query(PullRequest)
.filter(
PullRequest.message_id == message_id,
)
.first()
)
if pr:
return None, None, pr
repo = (
db.session.query(Repo)
.filter(
Repo.message_id == message_id,
)
.first()
)
if repo:
return repo, None, None
return None, None, None
# Path: server/tasks/lark/base.py
def with_authenticated_github():
def decorate(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""
1. 这个装饰器用来统一处理错误消息
2. github rest api调用出错的时候抛出异常
3. 这个装饰器捕获特定的异常，给操作者特定的报错消息
"""
try:
return func(*args, **kwargs)
except GitHubPermissionError as e:
try:
from .manage import send_manage_fail_message
app_id, message_id, content, raw_message = args[-4:]
host = os.environ.get("DOMAIN")
send_manage_fail_message(
f"[请点击绑定 GitHub 账号后重试]({host}/api/github/oauth)",
app_id,
message_id,
content,
raw_message,
)
except Exception as e:
logging.error(e)
except Exception as e:
raise e
return wrapper
return decorate
# Path: server/tasks/lark/pull_request.py
import json
import logging
from celery_app import app, celery
from connectai.lark.sdk import FeishuTextMessage
from model.schema import (
ChatGroup,
CodeApplication,
CodeUser,
IMUser,
PullRequest,
Repo,
Team,
TeamMember,
db,
)
from model.team import get_assignees_by_openid
from utils.github.repo import GitHubAppRepo
from utils.lark.pr_card import PullCard
from utils.lark.pr_manual import (
PrManual,
PullRequestDiff,
PullRequestLog,
PullRequestView,
)
from utils.lark.pr_tip_failed import PrTipFailed
from utils.lark.pr_tip_success import PrTipSuccess
from .base import (
get_bot_by_application_id,
get_git_object_by_message_id,
with_authenticated_github,
)
@celery.task()
def send_pull_request_failed_tip(
content, app_id, message_id, *args, bot=None, **kwargs
):
"""send new card message to user.
Args:
app_id: IMApplication.app_id.
message_id: lark message id.
content: error message
"""
if not bot:
| bot, _ = get_bot_by_application_id(app_id) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: camenduru/AnyDoor-online-hf
# Path: dinov2/dinov2/layers/attention.py
class Attention(nn.Module):
def __init__(
self,
dim: int,
num_heads: int = 8,
qkv_bias: bool = False,
proj_bias: bool = True,
attn_drop: float = 0.0,
proj_drop: float = 0.0,
) -> None:
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
self.scale = head_dim**-0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim, bias=proj_bias)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x: Tensor) -> Tensor:
B, N, C = x.shape
qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
q, k, v = qkv[0] * self.scale, qkv[1], qkv[2]
attn = q @ k.transpose(-2, -1)
attn = attn.softmax(dim=-1)
attn = self.attn_drop(attn)
x = (attn @ v).transpose(1, 2).reshape(B, N, C)
x = self.proj(x)
x = self.proj_drop(x)
return x
# Path: dinov2/dinov2/layers/attention.py
class MemEffAttention(Attention):
def forward(self, x: Tensor, attn_bias=None) -> Tensor:
if not XFORMERS_AVAILABLE:
assert attn_bias is None, "xFormers is required for nested tensors usage"
return super().forward(x)
B, N, C = x.shape
qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads)
q, k, v = unbind(qkv, 2)
if attn_bias is not None:
self_att_op = fmha.MemoryEfficientAttentionFlashAttentionOp
else:
self_att_op = None
x = memory_efficient_attention(q, k, v, attn_bias=attn_bias, op=self_att_op)
x = x.reshape([B, N, C])
x = self.proj(x)
x = self.proj_drop(x)
return x
# Path: dinov2/dinov2/layers/drop_path.py
class DropPath(nn.Module):
"""Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks)."""
def __init__(self, drop_prob=None):
super(DropPath, self).__init__()
self.drop_prob = drop_prob
def forward(self, x):
return drop_path(x, self.drop_prob, self.training)
# Path: dinov2/dinov2/layers/layer_scale.py
class LayerScale(nn.Module):
def __init__(
self,
dim: int,
init_values: Union[float, Tensor] = 1e-5,
inplace: bool = False,
) -> None:
super().__init__()
self.inplace = inplace
self.gamma = nn.Parameter(init_values * torch.ones(dim))
def forward(self, x: Tensor) -> Tensor:
return x.mul_(self.gamma) if self.inplace else x * self.gamma
# Path: dinov2/dinov2/layers/mlp.py
class Mlp(nn.Module):
def __init__(
self,
in_features: int,
hidden_features: Optional[int] = None,
out_features: Optional[int] = None,
act_layer: Callable[..., nn.Module] = nn.GELU,
drop: float = 0.0,
bias: bool = True,
) -> None:
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
self.fc1 = nn.Linear(in_features, hidden_features, bias=bias)
self.act = act_layer()
self.fc2 = nn.Linear(hidden_features, out_features, bias=bias)
self.drop = nn.Dropout(drop)
def forward(self, x: Tensor) -> Tensor:
x = self.fc1(x)
x = self.act(x)
x = self.drop(x)
x = self.fc2(x)
x = self.drop(x)
return x
# Path: dinov2/dinov2/layers/block.py
import logging
import torch
from typing import Callable, List, Any, Tuple, Dict
from torch import nn, Tensor
from .attention import Attention, MemEffAttention
from .drop_path import DropPath
from .layer_scale import LayerScale
from .mlp import Mlp
from xformers.ops import fmha
from xformers.ops import scaled_index_add, index_select_cat
# Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
# References:
# https://github.com/facebookresearch/dino/blob/master/vision_transformer.py
# https://github.com/rwightman/pytorch-image-models/tree/master/timm/layers/patch_embed.py
logger = logging.getLogger("dinov2")
try:
XFORMERS_AVAILABLE = True
except ImportError:
logger.warning("xFormers not available")
XFORMERS_AVAILABLE = False
class Block(nn.Module):
def __init__(
self,
dim: int,
num_heads: int,
mlp_ratio: float = 4.0,
qkv_bias: bool = False,
proj_bias: bool = True,
ffn_bias: bool = True,
drop: float = 0.0,
attn_drop: float = 0.0,
init_values=None,
drop_path: float = 0.0,
act_layer: Callable[..., nn.Module] = nn.GELU,
norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
attn_class: Callable[..., nn.Module] = Attention,
| ffn_layer: Callable[..., nn.Module] = Mlp, |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: OmchainFoundation/evm-indexer
# Path: evm_indexer/fetcher.py
class Fetcher:
def __init__(self, node_endpoint, is_poa=True):
self.web3 = Web3(Web3.HTTPProvider(node_endpoint))
if is_poa:
self.web3.middleware_onion.inject(geth_poa_middleware, layer=0)
if not self.web3.is_connected():
raise ConnectionError('Could not connect to node at {}'.format(node_endpoint))
def fetch_block(self, block_number):
try:
return self.web3.eth.get_block(block_number, full_transactions=True)
except Exception as e:
return None
def fetch_latest_block_number(self):
return self.web3.eth.block_number
def fetch_blocks_in_range(self, start_block, end_block):
blocks = []
for block_number in range(start_block, end_block + 1):
block = self.fetch_block(block_number)
if block:
blocks.append(block)
return blocks
def fetch_transactions_in_block(self, block_number):
block = self.fetch_block(block_number)
if block:
return block['transactions']
else:
return None
def fetch_transactions_in_range(self, start_block, end_block):
transactions = []
for block_number in range(start_block, end_block + 1):
print('Fetching block {}'.format(block_number))
block_transactions = self.fetch_transactions_in_block(block_number)
if block_transactions:
transactions.extend(block_transactions)
return transactions
# Path: evm_indexer/decoder.py
class Decoder:
def __init__(self, fetcher):
self.fetcher = fetcher
self.web3 = fetcher.web3
def get_erc20_transfers_from_tx(self, tx_receipt):
# Filter the logs for ERC20 Transfer events
transfer_events = []
for log in tx_receipt['logs']:
if log['topics'][0] == ERC20_TRANSFER_EVENT_SIGNATURE_HASH and len(log['topics']) == 3:
try:
from_address = self.web3.to_checksum_address('0x' + log['topics'][1][-40:])
to_address = self.web3.to_checksum_address('0x' + log['topics'][2][-40:])
token_address = log['address']
amount = Web3.to_int(hexstr=log['data'])
transfer_events.append({
'from': from_address,
'to': to_address,
'amount': amount,
'token_address': token_address
})
except BadFunctionCallOutput:
# Handle error if the log decoding fails
continue
return transfer_events
def get_native_transfers_from_tx(self, tx_hash):
tx = self.web3.eth.get_transaction(tx_hash)
value = tx['value']
if value == 0:
return []
from_address = self.web3.to_checksum_address(tx['from'])
to_address = self.web3.to_checksum_address(tx['to'])
return [{
'from': from_address,
'to': to_address,
'amount': value,
'token_address': None
}]
# Path: evm_indexer/internal_tracer.py
class InternalTracer:
def __init__(self, node_endpoint):
self.node_endpoint = node_endpoint
def get_tx_receipt(self, tx_hash):
try:
if type(tx_hash) != str:
tx_hash = Web3.to_hex(tx_hash)
headers = {'Content-Type': 'application/json'}
payload = {
"jsonrpc": "2.0",
"id": 1,
"method": "eth_getTransactionReceipt",
"params": [tx_hash]
}
response = requests.post(self.node_endpoint, headers=headers, data=json.dumps(payload))
if response.status_code == 200:
return response.json()
else:
return None
except Exception as e:
return None
def get_trace(self, tx_hash):
try:
headers = {'Content-Type': 'application/json'}
payload = {
"jsonrpc": "2.0",
"id": 1,
"method": "debug_traceTransaction",
"params": [
tx_hash,
]
}
response = requests.post(self.node_endpoint, headers=headers, data=json.dumps(payload))
if response.status_code == 200:
return response.json()
else:
return None
except Exception as e:
return None
def capture_internal_calls(self, trace_response, tx_receipt):
captured_calls = []
struct_logs = trace_response['result']['structLogs']
# Initial call from EOA to the contract
initiator_address = tx_receipt['from']
contract_address = tx_receipt['to'] # Contract being called
current_call = {'from': initiator_address, 'to': contract_address}
for log in struct_logs:
op = log['op']
stack = log['stack']
if op in ['CALL', 'CALLCODE', 'DELEGATECALL', 'STATICCALL']:
if len(stack) >= 7:
# Extract 'to' address and value from the stack
to_address = '0x' + stack[-2][-40:]
value = int(stack[-3], 16) if op == 'CALL' else 0 # Value is relevant only for CALL
captured_call = {'op': op, 'from': current_call['to'], 'to': to_address, 'value': value}
captured_calls.append(captured_call)
# Update the current call context
current_call['from'] = current_call['to']
current_call['to'] = to_address
return captured_calls
def calculate_net_changes(captured_calls):
net_changes = {}
for call in captured_calls:
if call['from'] not in net_changes:
net_changes[call['from']] = 0
if call['to'] not in net_changes:
net_changes[call['to']] = 0
net_changes[call['from']] -= call['value']
net_changes[call['to']] += call['value']
return net_changes
# Path: tests/test_range.py
import sys
import os
from evm_indexer.fetcher import Fetcher
from evm_indexer.decoder import Decoder
from evm_indexer.internal_tracer import InternalTracer
from web3 import Web3
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
NODE_URL = 'https://seed.omchain.io'
fetcher = Fetcher(NODE_URL, is_poa=True)
| decoder = Decoder(fetcher=fetcher) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: omkarcloud/google-scraper
# Path: src/write_output.py
def write_output(query, data, entity_type,transformer = kebab_case):
query_kebab = transformer(query)
make_folders(query_kebab)
csv_path = f"output/{query_kebab}/csv/"
json_path = f"output/{query_kebab}/json/"
create(data,[], csv_path, json_path, query_kebab,entity_type)
# Path: src/search.py
FAILED_DUE_TO_CREDITS_EXHAUSTED = "FAILED_DUE_TO_CREDITS_EXHAUSTED"
# Path: src/search.py
FAILED_DUE_TO_NO_KEY = "FAILED_DUE_TO_NO_KEY"
# Path: src/search.py
FAILED_DUE_TO_NOT_SUBSCRIBED = "FAILED_DUE_TO_NOT_SUBSCRIBED"
# Path: src/search.py
FAILED_DUE_TO_UNKNOWN_ERROR = "FAILED_DUE_TO_UNKNOWN_ERROR"
# Path: src/search.py
@request(**default_request_options)
def search(_, data, metadata):
if not metadata.get('key'):
return DontCache({
"data": None,
"error":FAILED_DUE_TO_NO_KEY
})
max_items = data['max']
url = "https://google-scraper.p.rapidapi.com/search/"
qp = {"query": data['query']}
params = {**qp, 'link':cl.join_link(url, query_params=qp)}
request_data = {**metadata, "params": params}
result = do_request(request_data)
initial_results = cl.select(result, 'data', 'results', default=[])
if not cl.select(result, 'error'):
more_results = cl.select(result, 'data', 'results', default=[])
print(f"Got {len(more_results)} more results")
while cl.select(result, 'data', 'next') and (max_items is None or len(initial_results) < max_items):
next = cl.select(result, 'data', 'next')
params = {**qp, 'link':next}
request_data = {**metadata, "params": params}
result = do_request(request_data)
if result.get('error'):
break
more_results = cl.select(result, 'data', 'results', default=[])
print(f"Got {len(more_results)} more results")
initial_results.extend(more_results)
if cl.select(result, 'error'):
return DontCache(result)
else:
if max_items is not None:
initial_results = initial_results[:max_items]
result['data']['results'] = initial_results
return result
# Path: src/google_scraper.py
from typing import List,Optional, Union, Dict
from botasaurus import bt
from .write_output import write_output
from .search import FAILED_DUE_TO_CREDITS_EXHAUSTED, FAILED_DUE_TO_NO_KEY,FAILED_DUE_TO_NOT_SUBSCRIBED, FAILED_DUE_TO_UNKNOWN_ERROR, search
def clean_data(social_details):
success, credits_exhausted, not_subscribed, unknown_error, no_key = [], [], [], [], []
for detail in social_details:
if detail.get("error") is None:
success.append(detail)
elif detail["error"] == FAILED_DUE_TO_CREDITS_EXHAUSTED:
credits_exhausted.append(detail)
elif detail["error"] == FAILED_DUE_TO_NOT_SUBSCRIBED:
not_subscribed.append(detail)
elif detail["error"] == FAILED_DUE_TO_UNKNOWN_ERROR:
unknown_error.append(detail)
elif detail["error"] == FAILED_DUE_TO_NO_KEY:
no_key.append(detail)
return success, credits_exhausted, not_subscribed, unknown_error, no_key
def print_data_errors(credits_exhausted, not_subscribed, unknown_error, no_key):
if credits_exhausted:
name = "queries" if len(credits_exhausted) > 1 else "query"
print(f"Could not get data for {len(credits_exhausted)} {name} due to credit exhaustion. Please consider upgrading your plan by visiting https://rapidapi.com/Chetan11dev/api/google-scraper/pricing to continue scraping data.")
if not_subscribed:
name = "queries" if len(not_subscribed) > 1 else "query"
print(f"Could not get data for {len(not_subscribed)} {name} as you are not subscribed to Google Scraper API. Please subscribe to a free plan by visiting https://rapidapi.com/Chetan11dev/api/google-scraper/pricing")
if unknown_error:
name = "queries" if len(unknown_error) > 1 else "query"
print(f"Could not get data for {len(unknown_error)} {name} due to Unknown Error.")
if no_key:
name = "queries" if len(no_key) > 1 else "query"
print(f"Could not get data for {len(no_key)} {name} as you are not subscribed to Google Scraper API. Please subscribe to a free plan by visiting https://rapidapi.com/Chetan11dev/api/google-scraper/pricing")
class Google:
@staticmethod
| def search(query: Union[str, List[str]], max: Optional[int] = None, key: Optional[str] =None, use_cache: bool = True) -> Dict: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: AI2lab/comfyUI-tool-2lab
# Path: nodes/common/utils.py
def downloadFileToTempFolder(url: str) -> str:
try:
response = requests.get(url)
response.raise_for_status()
try:
if not os.path.exists(temp_folder):
os.makedirs(temp_folder)
except Exception as e:
print(f"Fail to create directory '{temp_folder}. Error: {e}'")
return None
# temp file name
ext = getFileNameExt(url)
curtime = str(int(time.time()))
filename = curtime
if curtime != "":
filename = curtime+"."+ext
file_path = os.path.join(temp_folder,filename)
except:
return ''
return file_path
# Path: nodes/constants.py
def get_project_name(name):
return '{} ({})'.format(name, PROJECT_NAME)
# Path: nodes/constants.py
def get_project_category(sub_dirs = None):
start = "🦊" + PROJECT_NAME
if sub_dirs is None:
return start
else:
return "{}/{}".format(start,sub_dirs)
# Path: nodes/tool/preview.py
import numpy as np
import torch
from PIL import Image
from ..common.utils import downloadFileToTempFolder
from ..constants import get_project_name, get_project_category
NODE_CATEGORY = get_project_category("util/preview")
class ShowText:
@classmethod
def INPUT_TYPES(s):
return {
"required": {
"string": ("STRING", {"forceInput": True}),
},
"hidden": {
"unique_id": "UNIQUE_ID",
"extra_pnginfo": "EXTRA_PNGINFO",},
}
NAME = get_project_name('show_text')
CATEGORY = NODE_CATEGORY
RETURN_TYPES = ("STRING",)
RETURN_NAMES = ("string",)
OUTPUT_NODE = True
FUNCTION = "doWork"
def doWork(self, string, unique_id=None, extra_pnginfo=None):
return {"ui": {"string": [string, ]}, "result": (string,)}
class ShowWebImage:
@classmethod
def INPUT_TYPES(cls):
return {
"required": {
"image_url": ("STRING", {"multiline": False}),
"RGBA": (["false", "true"],{"default":False}),
},
}
NAME = get_project_name('show_web_image')
CATEGORY = NODE_CATEGORY
RETURN_TYPES = ("IMAGE", "MASK","TEXT","filePath")
RETURN_NAMES = ("image", "mask","image_url","filePath")
OUTPUT_NODE = True
FUNCTION = "doWork"
def doWork(self, image_url, RGBA):
print(image_url)
i = None
file_path = ''
try:
if image_url.startswith('http'):
file_path,i = self.download_image(image_url)
else:
file_path = image_url
i = Image.open(image_url)
if not i:
return
image = i
if not RGBA:
image = image.convert('RGB')
image = np.array(image).astype(np.float32) / 255.0
image = torch.from_numpy(image)[None,]
# RGBA - mask
if 'A' in i.getbands():
mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
mask = 1. - torch.from_numpy(mask)
else:
mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
return (image, mask, image_url,file_path)
except :
pass
return (None, None, image_url,file_path)
def download_image(self, url):
| file_path = downloadFileToTempFolder(url) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Amirtheahmed/ddd-cqrs-fastapi
# Path: src/contexts/photostore/photo/domain/PhotoRepository.py
class PhotoRepository(ABC):
async def create_one(self, photo: Photo) -> NoReturn:
raise NotImplementedError()
# Path: src/contexts/photostore/photo/domain/entities/Photo.py
class Photo(AggregateRoot):
def __init__(
self,
photo_id: PhotoId,
name: PhotoName,
user_id: UserId,
file: PhotoFile,
tags: PhotoTags,
):
super().__init__()
self.id = photo_id
self.name = name
self.user_id = user_id
self.file = file
self.tags = tags
@staticmethod
def create(photo_id: PhotoId, name: PhotoName, user_id: UserId, file: PhotoFile, tags: PhotoTags):
photo = Photo(photo_id, name, user_id, file, tags)
event = PhotoCreatedDomainEvent(photo.id.value(), photo_id, user_id, name, tags)
photo.record_event(event)
return photo
@staticmethod
def create_from_primitives(raw_data: Dict[str, Any]):
photo = Photo(
PhotoId(raw_data.get('id')),
PhotoName(raw_data.get('name')),
UserId(raw_data.get('user-id')),
PhotoFile(raw_data.get('file')),
PhotoTags([PhotoTag(tag) for tag in raw_data.get('tags', default=[])]),
)
return photo
def to_primitives(self) -> Union[Dict, List]:
return {
'id': self.id.value(),
'name': self.name.value(),
'user-id': self.user_id.value(),
'tags': self.tags.values(),
}
# Path: src/contexts/photostore/photo/domain/entities/PhotoFile.py
class PhotoFile(ValueObject):
def __init__(self, content: bytes):
super().__init__(content)
# Path: src/contexts/photostore/photo/domain/entities/PhotoId.py
class PhotoId(ValueObject):
def __init__(self, value: str):
super().__init__(value)
if not Uuid.is_valid_uuid(value):
raise ValueObjectValidationError(f'PhotoId must be UUID V4. <{value}> found.')
# Path: src/contexts/photostore/photo/domain/entities/PhotoName.py
class PhotoName(ValueObject):
def __init__(self, value: str):
super().__init__(value)
# Path: src/contexts/photostore/photo/domain/entities/UserId.py
class UserId(ValueObject):
def __init__(self, value: str):
super().__init__(value)
# Path: src/contexts/shared/domain/EventBus.py
class EventBus(Interface):
@abstractmethod
async def publish(self, events: List[DomainEvent]):
raise NotImplementedError()
@abstractmethod
def add_subscribers(self, subscribers: List[EventSubscriber]):
raise NotImplementedError()
@abstractmethod
def start(self):
raise NotImplementedError()
# Path: src/contexts/photostore/photo/application/createone/PhotoCreator.py
from src.contexts.photostore.photo.domain.PhotoRepository import PhotoRepository
from src.contexts.photostore.photo.domain.entities.Photo import Photo
from src.contexts.photostore.photo.domain.entities.PhotoFile import PhotoFile
from src.contexts.photostore.photo.domain.entities.PhotoId import PhotoId
from src.contexts.photostore.photo.domain.entities.PhotoName import PhotoName
from src.contexts.photostore.photo.domain.entities.UserId import UserId
from src.contexts.shared.domain.EventBus import EventBus
class PhotoCreator:
def __init__(self, photo_repository: PhotoRepository, event_bus: EventBus):
self.__photo_repository = photo_repository
self.__event_bus = event_bus
| async def run(self, photo_id: PhotoId, name: PhotoName, user_id: UserId, file: PhotoFile): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: JINO-ROHIT/RAG-with-Memory
# Path: vlite_db/model.py
class EmbeddingModel:
'''
EmbeddingModel runs a transformer model and returns the embedding for a given text.
'''
def __init__(self, model_name='sentence-transformers/all-MiniLM-L6-v2'):
self.tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True) # use_fast=True
self.model = AutoModel.from_pretrained(model_name)
self.dimension = self.model.embeddings.position_embeddings.embedding_dim
self.max_seq_length = self.model.embeddings.position_embeddings.num_embeddings
#print("Tokenizer:", self.tokenizer)
# print("Dimension:", self.dimension)
# print("Max sequence length:", self.max_seq_length)
def embed(self, texts, max_seq_length=256, device="mps"):
if(torch.backends.mps.is_available()):
dev = torch.device("mps")
else:
dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
device = torch.device(dev) # Create a torch.device object
print("Device:", device)
self.model.to(device) # Move the model to the specified device
encoded_input = self.tokenizer(texts, padding=True, truncation=True, return_tensors='pt', max_length=max_seq_length)
print("Encoded input done",encoded_input['input_ids'].shape)
if encoded_input['input_ids'].shape[0] > 1300:
print("Encoded input too large, defaulting to CPU")
device = torch.device("cpu")
self.model.to(device) # Move the model to the specified device
encoded_input = {name: tensor.to(device) for name, tensor in encoded_input.items()} # Move all input tensors to the specified device
print("Encoded input moved to device")
with torch.no_grad():
model_output = self.model(**encoded_input)
embeddings = mean_pooling(model_output, encoded_input['attention_mask'], device=device)
tensor_embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
np_embeddings = tensor_embeddings.cpu().numpy() # Move tensor to CPU before converting to numpy
return np_embeddings
def token_count(self, texts):
tokens = 0
for text in texts:
tokens+=len(self.tokenizer.tokenize(text))
# Path: vlite_db/utils.py
def chop_and_chunk(text, max_seq_length=1024):
"""
Chop and chunk a text into smaller pieces of text.
Args:
text: string, list of strings, or array of strings
max_seq_length: maximum length of the text
"""
chunks = []
chunk = ''
for tokens in text.split(' '):
count = 0
chunk += tokens + ' '
if len(chunk) > max_seq_length:
chunks.append(chunk)
chunk = ''
return chunks
# Path: vlite_db/utils.py
def cos_sim(a, b):
sims = a @ b.T
sims /= np.linalg.norm(a) * np.linalg.norm(b, axis=1)
return sims
# Path: vlite_db/main.py
import numpy as np
import datetime
from uuid import uuid4
from .model import EmbeddingModel
from .utils import chop_and_chunk, cos_sim
class VLite:
'''
vlite is a simple vector database that stores vectors in a numpy array.
'''
def __init__(self, collection=None,device='mps',model_name=None):
# Filename must be unique between runs. Saving to the same file will append vectors to previous run's vectors
if collection is None:
current_datetime = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
collection = f"vlite_{current_datetime}.npz"
self.collection = collection
self.device = device
self.model = EmbeddingModel() if model_name is None else EmbeddingModel(model_name)
try:
with np.load(self.collection, allow_pickle=True) as data:
self.texts = data['texts'].tolist()
self.metadata = data['metadata'].tolist()
self.vectors = data['vectors']
except FileNotFoundError:
self.texts = []
self.metadata = {}
self.vectors = np.empty((0, self.model.dimension))
def add_vector(self, vector):
self.vectors = np.vstack((self.vectors, vector))
def get_similar_vectors(self, vector, top_k=5):
sims = cos_sim(vector, self.vectors)
sims = sims[0]
# print("[get_similar_vectors] Sims:", sims.shape)
top_k_idx = np.argsort(sims)[::-1][:top_k]
# print("[get_similar_vectors] Top k idx:", top_k_idx)
# print("[get_similar_vectors] Top k sims:", sims[top_k_idx])
return top_k_idx, sims[top_k_idx]
def memorize(self, text, id=None, metadata=None):
id = id or str(uuid4())
| chunks = chop_and_chunk(text) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: avataar/bg_electricity_regulated_pricing
# Path: custom_components/bg_electricity_regulated_pricing/const.py
CONF_TARIFF_TYPE = "tariff_type"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
CONF_PROVIDER = "provider"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
CONF_CUSTOM_DAY_PRICE = "custom_day_price"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
CONF_CUSTOM_NIGHT_PRICE = "custom_night_price"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
PROVIDER_PRICES = {
# Section 6.1, https://www.dker.bg/uploads/reshenia/2023/res_c_14_23.pdf
"electrohold": {
"day": .14875,
"night": .05997,
"fees": .01623 + .00754 + .04232
},
# Section 6.1, https://www.dker.bg/uploads/reshenia/2023/res_c_14_23.pdf
"evn": {
"day": .14667,
"night": .05531,
"fees": .01623 + .00803 + .04366
},
# Section 6.3, https://www.dker.bg/uploads/reshenia/2023/res_c_14_23.pdf
"energo_pro": {
"day": .15076,
"night": .05279,
"fees": .01623 + .00959 + .04825
}
}
# Path: custom_components/bg_electricity_regulated_pricing/const.py
CONF_CLOCK_OFFSET = "clock_offset"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
BGN_PER_KILOWATT_HOUR = f"BGN/{UnitOfEnergy.KILO_WATT_HOUR}"
# Path: custom_components/bg_electricity_regulated_pricing/const.py
VAT_RATE = 0.2
# Path: custom_components/bg_electricity_regulated_pricing/const.py
DOMAIN = "bg_electricity_regulated_pricing"
# Path: custom_components/bg_electricity_regulated_pricing/sensor.py
from homeassistant.components.sensor import SensorEntity, SensorEntityDescription, \
SensorStateClass
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.util import utcnow
from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
from .const import CONF_TARIFF_TYPE, CONF_PROVIDER, CONF_CUSTOM_DAY_PRICE, \
CONF_CUSTOM_NIGHT_PRICE, PROVIDER_PRICES, CONF_CLOCK_OFFSET, \
BGN_PER_KILOWATT_HOUR, VAT_RATE, DOMAIN
"""Sensor platform for bg_electricity_regulated_pricing integration."""
from __future__ import annotations
async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Initialize bg_electricity_regulated_pricing config entry."""
name = config_entry.title
unique_id = config_entry.entry_id
tariff_type = config_entry.options[CONF_TARIFF_TYPE]
clock_offset = config_entry.options[CONF_CLOCK_OFFSET]
provider = config_entry.options[CONF_PROVIDER]
if provider == "custom":
| price_day = config_entry.options[CONF_CUSTOM_DAY_PRICE] |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Qazalbash/jaxtro
# Path: jaxtro/utils/parser.py
def parse_config(config_path: str) -> dict:
# Path: jaxtro/utils/popgen.py
class PopulationGenerator:
"""Class to generate population and save them to disk."""
def __init__(self, general: dict, models: dict) -> None:
"""__init__ method for PopulationGenerator.
Parameters
----------
config : dict
Configuration dictionary for PopulationGenerator.
"""
self.check_general(general)
for model in models:
self.check_models(model)
self._size: int = general["size"]
self._error_scale: float = general["error_scale"]
self._error_size: int = general["error_size"]
self._root_container: str = general["root_container"]
self._event_filename: str = general["event_filename"]
self._config_filename: str = general["config_filename"]
self._models: list[ContinuousRV] = models
@staticmethod
def check_general(general: dict) -> None:
"""Check if all the required configs are present."""
assert general.get("size", None) is not None
assert general.get("error_scale", None) is not None
assert general.get("error_size", None) is not None
assert general.get("root_container", None) is not None
assert general.get("event_filename", None) is not None
assert general.get("config_filename", None) is not None
@staticmethod
def check_models(model: dict) -> None:
"""Check if all the required configs are present."""
assert model.get("model", None) is not None
assert model.get("config_vars", None) is not None
assert model.get("col_names", None) is not None
assert model.get("params", None) is not None
def generate(self):
"""Generate population and save them to disk."""
os.makedirs(self._root_container, exist_ok=True)
container = f"{self._root_container}"
os.makedirs(container, exist_ok=True)
config_vals = []
col_names = []
realisations = np.empty((self._size, 0))
for model in self._models:
model_instance: ContinuousRV = eval(model["model"])(**model["params"])
rvs = model_instance.rvs(self._size)
realisations = jnp.concatenate((realisations, rvs), axis=1)
config_vals.extend([(x, model["params"][x]) for x in model["config_vars"]])
col_names.extend(model["col_names"])
dump_configurations(
f"{container}/{self._config_filename}",
*config_vals,
)
for event_num, realisation in tqdm(enumerate(realisations),
desc=f"Generating events",
total=self._size,
unit=" events",
unit_scale=True):
filename = f"{container}/{self._event_filename.format(event_num)}"
realisation_err = add_normal_error(
*realisation,
scale=self._error_scale,
size=self._error_size,
)
np.savetxt(
filename,
realisation_err,
header="\t".join(col_names),
)
# Path: jaxtro/main.py
from .utils import PopulationGenerator, parser
# Copyright 2023 The Jaxtro Authors
# 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 writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
def main():
args = parser.cmd_parser.parse_args()
configuration_dict = parser.parse_config(args.my_config)
general = configuration_dict['general']
models = [configuration_dict.get('mass_model', None), configuration_dict.get('spin_model', None)]
| pg = PopulationGenerator(general=general, models=models) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: smonsays/modular-hyperteacher
# Path: metax/data/base.py
class Dataset(NamedTuple):
x: Array
y: Array
info: Dict = dict()
# Path: metax/data/utils.py
def batch_generator(rng, datastruct, steps, batch_size):
"""
Add leading dims to datastruct resulting in (steps, batch_size, *data.shape).
If batch_size is None, repeat each data leaf, otherwise sample random batches.
"""
if batch_size is None or batch_size < 1:
# Repeat whole data on new leading dim for number of steps
def repeat(x):
return jnp.repeat(jnp.expand_dims(x, axis=0), steps, axis=0)
return jtu.tree_map(repeat, datastruct)
else:
rng_batch = jax.random.split(rng, steps)
batch_get_batch = jax.vmap(get_batch, in_axes=(0, None, None))
return batch_get_batch(rng_batch, datastruct, batch_size)
# Path: metax/module/init.py
class LearnedInit(MetaModule):
def __init__(self, loss_fn_inner, loss_fn_outer, base_learner, reg_strength):
super().__init__(loss_fn_inner, loss_fn_outer)
self.base_learner = base_learner
if reg_strength is not None:
# Use iMAML regularizer towards meta-learned init
key_map = {"base_learner": "base_learner_init"}
self.loss_fn_inner += energy.iMAML(
reg_strength=reg_strength,
key_map=key_map,
reduction="sum"
)
def __call__(self, rng, state, hstate, params, hparams, input, is_training):
output, state = self.base_learner.apply(
params.base_learner, state.base_learner, rng, input, is_training
)
return output, (LearnedInitState(state), hstate)
def reset_hparams(self, rng, sample_input):
params_base_learner, _ = self.base_learner.init(rng, sample_input, is_training=True)
# Re-using params container here to simplify implementation of reptile
return LearnedInitMetaParams(params_base_learner), LearnedInitMetaState()
def reset_params(self, rng, hparams, hstate, sample_input):
_, state_base_learner = self.base_learner.init(rng, sample_input, is_training=True)
return LearnedInitParams(hparams.base_learner_init), LearnedInitState(state_base_learner)
# Path: metax/module/init.py
class LearnedInitMetaParams(NamedTuple):
base_learner_init: Dict
# Path: metax/utils/utils.py
def append_keys(dictionary, suffix):
return {key + "_" + suffix: value for key, value in dictionary.items()}
# Path: metax/learner/base.py
class MetaGradLearner(MetaLearnerInnerGradientDescent):
"""
Abstract base class for meta-learning algorithms that estimate the meta-gradient.
"""
def __init__(
self,
meta_model: MetaModule,
batch_size: int,
steps_inner: int,
optim_fn_inner: optax.GradientTransformation,
optim_fn_outer: optax.GradientTransformation,
):
super().__init__(meta_model, batch_size, steps_inner, optim_fn_inner)
self.optim_fn_outer = optim_fn_outer
self.batch_grad = jax.vmap(self.grad, in_axes=(0, None, None, 0))
@abc.abstractmethod
def grad(
self, rng: chex.PRNGKey, hstate: HState, hparams: HParams, metadataset: data.MetaDataset
) -> Tuple[chex.Array, HState, Dict]:
pass
def update(self, rng, meta_state, metadataset: data.MetaDataset):
rng_batch = jax.random.split(rng, len(metadataset.train.x))
hgrads, hstate, metrics = self.batch_grad(
rng_batch, meta_state.hstate, meta_state.hparams, metadataset
)
hgrads = jtu.tree_map(partial(jnp.mean, axis=0), hgrads) # Average hgrads across tasks
hparams_update, optim_state = self.optim_fn_outer.update(
hgrads, meta_state.optim, meta_state.hparams
)
hparams = optax.apply_updates(meta_state.hparams, hparams_update)
# HACK: Averaging over the model state might result in unexpected behaviour
# HACK: Averaging might change dtype (e.g. int to float), this simply casts it back
hstate_dtypes = jtu.tree_map(jnp.dtype, hstate)
hstate = jtu.tree_map(partial(jnp.mean, axis=0), hstate)
hstate = jtu.tree_map(jax.lax.convert_element_type, hstate, hstate_dtypes)
metrics = jtu.tree_map(partial(jnp.mean, axis=0), metrics)
return MetaLearnerState(hparams=hparams, optim=optim_state, hstate=hstate), metrics
# Path: metax/learner/reptile.py
import jax
import jax.numpy as jnp
import jax.tree_util as jtu
import optax
from metax.data import Dataset, batch_generator
from metax.module import LearnedInit
from metax.module.init import LearnedInitMetaParams
from metax.utils import append_keys
from .base import MetaGradLearner
"""
Copyright (c) Simon Schug
All rights reserved.
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
| class Reptile(MetaGradLearner): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: AContesini/Convert_PDF_to_DOCX_or_vice-versa
# Path: venv/Lib/site-packages/tqdm/auto.py
class tqdm(notebook_tqdm, asyncio_tqdm): # pylint: disable=inconsistent-mro
pass
# Path: venv/Lib/site-packages/tqdm/std.py
class TqdmWarning(Warning):
"""base class for all tqdm warnings.
Used for non-external-code-breaking errors, such as garbled printing.
"""
def __init__(self, msg, fp_write=None, *a, **k):
if fp_write is not None:
fp_write("\n" + self.__class__.__name__ + ": " + str(msg).rstrip() + '\n')
else:
super(TqdmWarning, self).__init__(msg, *a, **k)
# Path: venv/Lib/site-packages/tqdm/contrib/concurrent.py
from contextlib import contextmanager
from operator import length_hint
from os import cpu_count
from ..auto import tqdm as tqdm_auto
from ..std import TqdmWarning
from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import ProcessPoolExecutor
from warnings import warn
"""
Thin wrappers around `concurrent.futures`.
"""
__author__ = {"github.com/": ["casperdcl"]}
__all__ = ['thread_map', 'process_map']
@contextmanager
def ensure_lock(tqdm_class, lock_name=""):
"""get (create if necessary) and then restore `tqdm_class`'s lock"""
old_lock = getattr(tqdm_class, '_lock', None) # don't create a new lock
lock = old_lock or tqdm_class.get_lock() # maybe create a new lock
lock = getattr(lock, lock_name, lock) # maybe subtype
tqdm_class.set_lock(lock)
yield lock
if old_lock is None:
del tqdm_class._lock
else:
tqdm_class.set_lock(old_lock)
def _executor_map(PoolExecutor, fn, *iterables, **tqdm_kwargs):
"""
Implementation of `thread_map` and `process_map`.
Parameters
----------
tqdm_class : [default: tqdm.auto.tqdm].
max_workers : [default: min(32, cpu_count() + 4)].
chunksize : [default: 1].
lock_name : [default: "":str].
"""
kwargs = tqdm_kwargs.copy()
if "total" not in kwargs:
kwargs["total"] = length_hint(iterables[0])
tqdm_class = kwargs.pop("tqdm_class", tqdm_auto)
max_workers = kwargs.pop("max_workers", min(32, cpu_count() + 4))
chunksize = kwargs.pop("chunksize", 1)
lock_name = kwargs.pop("lock_name", "")
with ensure_lock(tqdm_class, lock_name=lock_name) as lk:
# share lock in case workers are already using `tqdm`
with PoolExecutor(max_workers=max_workers, initializer=tqdm_class.set_lock,
initargs=(lk,)) as ex:
return list(tqdm_class(ex.map(fn, *iterables, chunksize=chunksize), **kwargs))
def thread_map(fn, *iterables, **tqdm_kwargs):
"""
Equivalent of `list(map(fn, *iterables))`
driven by `concurrent.futures.ThreadPoolExecutor`.
Parameters
----------
tqdm_class : optional
`tqdm` class to use for bars [default: tqdm.auto.tqdm].
max_workers : int, optional
Maximum number of workers to spawn; passed to
`concurrent.futures.ThreadPoolExecutor.__init__`.
[default: max(32, cpu_count() + 4)].
"""
return _executor_map(ThreadPoolExecutor, fn, *iterables, **tqdm_kwargs)
def process_map(fn, *iterables, **tqdm_kwargs):
"""
Equivalent of `list(map(fn, *iterables))`
driven by `concurrent.futures.ProcessPoolExecutor`.
Parameters
----------
tqdm_class : optional
`tqdm` class to use for bars [default: tqdm.auto.tqdm].
max_workers : int, optional
Maximum number of workers to spawn; passed to
`concurrent.futures.ProcessPoolExecutor.__init__`.
[default: min(32, cpu_count() + 4)].
chunksize : int, optional
Size of chunks sent to worker processes; passed to
`concurrent.futures.ProcessPoolExecutor.map`. [default: 1].
lock_name : str, optional
Member of `tqdm_class.get_lock()` to use [default: mp_lock].
"""
if iterables and "chunksize" not in tqdm_kwargs:
# default `chunksize=1` has poor performance for large iterables
# (most time spent dispatching items to workers).
longest_iterable_len = max(map(length_hint, iterables))
if longest_iterable_len > 1000:
warn("Iterable length %d > 1000 but `chunksize` is not set."
" This may seriously degrade multiprocess performance."
" Set `chunksize=1` or more." % longest_iterable_len,
| TqdmWarning, stacklevel=2) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: willfinnigan/RetroBioCat_2
# Path: rbc2/configs/download_data_files/download_aizynthfinder.py
def does_aizynthfinder_exist() -> bool:
if not os.path.exists(f"{path_to_data_folder}/aizynthfinder/uspto_model.hdf5"):
return False
if not os.path.exists(f"{path_to_data_folder}/aizynthfinder/uspto_templates.hdf5"):
return False
return True
# Path: rbc2/configs/download_data_files/download_aizynthfinder.py
def download_aizynthfinder_model():
aizynthfinder_model = "https://figshare.com/ndownloader/files/23086454"
aizynthfinder_templates = "https://figshare.com/ndownloader/files/23086457"
# if aizynthfinder folder doesn't exist, create it with Pathlib
directory = f"{path_to_data_folder}/aizynthfinder"
Path(directory).mkdir(parents=True, exist_ok=True)
filename = "uspto_model.hdf5"
filepath = f"{directory}/{filename}"
download_file(aizynthfinder_model, filepath)
filename = "uspto_templates.hdf5"
filepath = f"{directory}/{filename}"
download_file(aizynthfinder_templates, filepath)
# Path: rbc2/utils/add_logger.py
def add_logger(name, level='DEBUG'):
logger = logging.getLogger(name)
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(level)
logger.propagate = False
return logger
# Path: rbc2/configs/data_path.py
DEFAULT_DATA_FOLDER = str(Path(__file__).parents[1]) + '/data'
RBC2_DATA_PATH = os.getenv('RBC2_DATA_PATH')
# Path: rbc2/configs/expansion_config.py
class Expansion_Config():
def __init__(self):
# rule application
self.allow_chiral_symmetry = False
self.check_chiral_products = True
self.combine_enantiomers = True
self.allow_cyclic_reaction_outcomes = False
self.clean_brackets = True
# reaction parsing
self.allow_backwards = False
self.allow_duplicates = False
self.duplicates_require_same_expander = True
self.duplicates_require_same_domain = False
self.duplicates_require_same_name = False
self.merge_duplicate_metadata = True
self.force_rdkit_smis = True
# expanders general
self.max_reactions = None # max reactions (not options)
# reaction filtering and blocking
self.use_max_mw_for_enzymes = False
self.max_mw_to_use_enzymes = 300
def update_from_dict(self, attr_dict):
current_dict = self.to_dict()
for key, value in attr_dict.items():
if key in current_dict:
setattr(self, key, value)
return self
def to_dict(self):
return self.__dict__
# Path: rbc2/utils/load_keras_models.py
def tensorflow_imports():
def __init__(self, filename):
def __len__(self):
def predict(self, *args: np.ndarray, **_: np.ndarray):
CUSTOM_OBJECTS = {"top10_acc": top10_acc, "top50_acc": top50_acc}
class LocalKerasModel:
# Path: rbc2/utils/fingerprints.py
def get_mol_fingerprint(rd_mol, radius=2, nBits=2048):
def get_reaction_fingerprint(product_mol, substrate_mols, radius=2, nBits=2048):
# Path: rbc2/expansion/expanders/action_getters/aizynthfinder/aizynthfinder_actions.py
import time
import numpy as np
import pandas as pd
from rdkit import Chem
from rbc2.configs.download_data_files.download_aizynthfinder import does_aizynthfinder_exist, \
download_aizynthfinder_model
from rbc2.utils.add_logger import add_logger
from rbc2.configs.data_path import path_to_data_folder
from rbc2.configs.expansion_config import Expansion_Config
from rbc2.utils import load_keras_models, fingerprints
data_folder = f'{path_to_data_folder}/aizynthfinder'
class AizynthfinderActionGetter():
def __init__(self,
template_column='retro_template',
cutoff_cumulative=0.995,
cutoff_number=50,
log_level='WARNING'):
self.logger = add_logger('AIZynthfinder_Actions', level=log_level)
self.policy_model = None
self.templates = None
self.template_column = template_column
self.cutoff_cumulative = cutoff_cumulative
self.cutoff_number = cutoff_number
if does_aizynthfinder_exist() == False:
download_aizynthfinder_model()
def load_model(self):
if self.policy_model == None:
policy_path = data_folder + '/uspto_model.hdf5'
self.policy_model = load_keras_models.LocalKerasModel(policy_path)
if self.templates == None:
templates_path = data_folder + '/uspto_templates.hdf5'
self.templates = pd.read_hdf(templates_path, "table")
def get_actions(self, smi):
reactions = []
priors = []
template_column = self.template_column
mol = Chem.MolFromSmiles(smi)
all_transforms_prop = self._predict(mol)
probable_transforms_idx = self._cutoff_predictions(all_transforms_prop)
possible_moves = self.templates.iloc[probable_transforms_idx]
probs = all_transforms_prop[probable_transforms_idx]
priors.extend(probs)
for idx, (move_index, move) in enumerate(possible_moves.iterrows()):
metadata = dict(move)
del metadata[template_column]
metadata["policy_probability"] = round(float(probs[idx]), 5)
metadata["template_code"] = move_index
reaction = {'smarts': move[template_column],
'metadata': metadata,
'prior': priors[idx]}
reactions.append(reaction)
return reactions
def get_rxns(self, smile):
if self.policy_model == None:
self.load_model()
reactions = self.get_actions(smile)
rxns = {}
metadata = {}
for reaction in reactions:
name = f"Chem_{reaction['metadata']['classification']}"
num = 1
extra_string = f"__{num}"
while name+extra_string in rxns:
extra_string = f"__{num}"
num += 1
name = name+extra_string
smarts = reaction['smarts']
if self._does_smarts_only_one_reactants(smarts):
rxns[name] = [smarts]
else:
rxns[name] = []
metadata[name] = reaction['metadata']
return rxns, metadata
def _predict(self, mol):
| fingerprint = fingerprints.get_mol_fingerprint(mol, 2, nBits=len(self.policy_model)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: DomingoJoseCab/AutoTube
# Path: utils/edition/autoediting.py
def load_videos(videos_path):
video_list = []
videos = os.listdir(videos_path)
for vid in videos:
video = VideoFileClip(os.path.join(videos_path,vid))
video_list.append(video)
return video_list
# Path: utils/edition/autoediting.py
def load_audio(audio_path):
audio_list = []
audios = os.listdir(audio_path)
for au in audios:
audio = AudioFileClip(os.path.join(audio_path,au))
audio_list.append(audio)
return audio_list
# Path: utils/edition/autoediting.py
def generate_product(video, audio):
ordered_clips = generate_subclip(video)
repetitions = ceil(audio.duration / sum(clip.duration for clip in ordered_clips))
final_clips_sequence = ordered_clips * repetitions
final_clips_sequence = concatenate_videoclips(final_clips_sequence).subclip(0, audio.duration+1)
final_video = final_clips_sequence.set_audio(CompositeAudioClip([audio.set_start(0.5)]))
return final_video
# Path: utils/edition/autoediting.py
def generate_intro(videos, audio):
selected_video = choice(videos)
audio_duration = audio.duration
total_video_duration = audio_duration + 1
start_time = choice(range(int(selected_video.duration - total_video_duration)))
video_clip = selected_video.subclip(start_time, start_time + total_video_duration)
adjusted_audio = CompositeAudioClip([audio.set_start(0.5)])
video_clip = video_clip.set_audio(adjusted_audio)
return video_clip
# Path: utils/edition/autoediting.py
def generate_outro(videos, audio):
selected_video = choice(videos)
audio_duration = audio.duration
clips = generate_subclip(selected_video)
total_video_duration = audio_duration + 25
repetitions = ceil(total_video_duration / sum(clip.duration for clip in clips))
final_clips = clips * repetitions
final_clips = concatenate_videoclips(final_clips).subclip(0, total_video_duration)
adjusted_audio = CompositeAudioClip([audio.set_start(0.5)])
video_clip = final_clips.set_audio(adjusted_audio)
return video_clip
# Path: utils/edition/autotext.py
def title_intro(title:str, video):
texto = TextClip(title, fontsize=40, color='white', font='Bebas Neue Bold')
texto = texto.set_position('center').set_duration(6)
color_clip = ColorClip(video.size, color=(0, 0, 0), duration=texto.duration)
color_clip = color_clip.set_opacity(0.9) # Ajusta la opacidad
color_clip = color_clip.set_start(4)
texto = texto.set_start(4).crossfadein(1)
video_opaco = CompositeVideoClip([video, color_clip])
video_final = CompositeVideoClip([video_opaco, texto])
return video_final
# Path: utils/edition/edit.py
import os
import json
from moviepy.editor import CompositeVideoClip
from utils.edition.autoediting import load_videos, load_audio, generate_product, generate_intro, generate_outro
from utils.edition.autotext import title_intro
from moviepy.config import change_settings
# ==============================================================================
# AutoTube Script
# Creado por: Domingo Caballero
# Canal de YouTube: https://www.youtube.com/@emprendedomingo?=sub_confirmation=1
# Lista de Correo: https://emprendecondomingo.substack.com/
# ==============================================================================
def main(videos_path, audios_path, output_path, names, base_path):
videos = load_videos(videos_path)
audios = load_audio(audios_path)
audio_intro = audios.pop(0)
audio_outro = audios.pop(-1)
| intro = generate_intro(videos, audio_intro)
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: gregorybchris/typogenetics
# Path: typogenetics/search.py
class Editor:
PROB_MUTATE = 0.80
PROB_INSERT = 0.10
PROB_DELETE = 0.10
@classmethod
def edit(cls, strand: Strand, rng: Generator) -> Strand:
edit_type = cls.select_edit_type(rng)
if edit_type == EditType.MUTATE:
return cls.mutate(strand, rng)
if edit_type == EditType.INSERT:
return cls.insert(strand, rng)
if edit_type == EditType.DELETE:
return cls.delete(strand, rng)
@classmethod
def mutate(cls, strand: Strand, rng: Generator) -> Strand:
r1 = rng.integers(0, len(strand))
new_bases = strand.bases.copy()
base = new_bases[r1]
while new_bases[r1] == base:
all_bases = [Base.A, Base.C, Base.G, Base.T]
r2 = rng.integers(0, len(all_bases))
new_bases[r1] = all_bases[r2]
return Strand(new_bases)
@classmethod
def insert(cls, strand: Strand, rng: Generator) -> Strand:
r1 = rng.integers(0, len(strand) + 1)
new_bases = strand.bases.copy()
all_bases = [Base.A, Base.C, Base.G, Base.T]
r2 = rng.integers(0, len(all_bases))
new_bases.insert(r1, all_bases[r2])
return Strand(new_bases)
@classmethod
def delete(cls, strand: Strand, rng: Generator) -> Strand:
r1 = rng.integers(0, len(strand))
new_bases = strand.bases.copy()
new_bases.pop(r1)
return Strand(new_bases)
@classmethod
def select_edit_type(cls, rng: Generator) -> EditType:
r = rng.random()
edit_types = [
(EditType.MUTATE, cls.PROB_MUTATE),
(EditType.INSERT, cls.PROB_INSERT),
(EditType.DELETE, cls.PROB_DELETE),
]
assert np.isclose(sum(dict(edit_types).values()), 1.0)
for edit_type, prob in edit_types:
if r <= prob:
return edit_type
r -= prob
raise ValueError("Random number is not in range [0, 1]")
# Path: typogenetics/search.py
class EditType(StrEnum):
MUTATE = auto()
INSERT = auto()
DELETE = auto()
# Path: typogenetics/typogenetics.py
class Strand:
bases: List[Base]
@classmethod
def from_str(cls, strand_str: str) -> "Strand":
bases = []
for base_str in strand_str:
if base_str == " ":
continue
base = Base.from_str(base_str)
bases.append(base)
return cls(bases)
def iter_bases(self) -> Iterator[Base]:
yield from self.bases
def iter_duplets(self) -> Iterator[Duplet]:
unit = 0
while True:
if unit + 1 >= len(self):
break
yield (self[unit], self[unit + 1])
unit += 2
def __repr__(self) -> str:
return "".join([str(b) for b in self.bases])
def __str__(self) -> str:
return self.__repr__()
def __getitem__(self, unit: int) -> Base:
return self.bases[unit]
def __len__(self) -> int:
return len(self.bases)
# Path: tests/test_search.py
import numpy as np
from typogenetics.search import Editor, EditType
from typogenetics.typogenetics import Strand
class TestSearch:
def test_select_edit_type(self) -> None:
rng = np.random.default_rng(42)
assert Editor.select_edit_type(rng) == EditType.INSERT
def test_mutate(self) -> None:
rng = np.random.default_rng(42)
| strand = Strand.from_str("ACGT") |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: chaoren2357/gsplatstudio
# Path: gsplatstudio/data/processor/base_processor.py
class BaseDataProcessor(ABC):
def __init__(self, cfg, logger, source_path) -> None:
self.cfg = parse_structured(self.config_class, cfg)
self.logger = logger
self.source_path_str = source_path
@property
@abstractmethod
def config_class(self):
pass
@property
def should_skip(self):
pass
@abstractmethod
def run(self):
pass
def run_command_with_realtime_output(self, cmd):
"""
Run the specified command and output the results in real-time.
:param cmd: The command string to run.
:return: The exit code of the command.
"""
self.logger.info(f"Running command: {cmd}")
# Start the process
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
# Read output in real-time
while True:
output = process.stdout.readline()
if output == '' and process.poll() is not None:
break
if output:
self.logger.verbose(output.strip())
# Read any remaining error output
stderr_output = process.stderr.read()
if stderr_output:
self.logger.error("Error Output:")
self.logger.error(stderr_output.strip())
# Return the exit code
return process.returncode
# Path: gsplatstudio/utils/general_utils.py
def load_json(json_file):
with open(json_file, 'r') as file:
return json.load(file)
# Path: gsplatstudio/utils/camera_utils.py
def transform_camera_from_carla_matrix_to_colmap_quaternion(camera_data):
x_carla,y_carla,z_carla,roll_carla,pitch_carla,yaw_carla = camera_data['x'],camera_data['y'],camera_data['z'],camera_data['roll'],camera_data['pitch'],camera_data['yaw']
x = y_carla
y = -z_carla
z = x_carla
roll = pitch_carla
pitch = yaw_carla
yaw = roll_carla
C2W_matrix = get_transform_matrix(x, y, z, pitch, roll, yaw)
W2C_matrix = np.linalg.inv(C2W_matrix)
W2C_quaternion = rotmat2qvec(W2C_matrix[:3, :3])
W2C_translation = W2C_matrix[:3, 3]
return W2C_quaternion, W2C_translation
# Path: gsplatstudio/utils/camera_utils.py
def fov_to_focal_length(fov_degrees, width):
fov_radians = np.radians(fov_degrees)
focal_length = (width / 2) / np.tan(fov_radians / 2)
return focal_length
# Path: gsplatstudio/data/processor/colmapWcam_processor.py
import gsplatstudio
import sqlite3
from gsplatstudio.utils.type_utils import *
from gsplatstudio.data.processor.base_processor import BaseDataProcessor
from pathlib import Path
from gsplatstudio.utils.general_utils import load_json
from gsplatstudio.utils.camera_utils import transform_camera_from_carla_matrix_to_colmap_quaternion, fov_to_focal_length
@dataclass
class ColmapWithCamProcessorConfig:
use_gpu: bool = True
camera: str = "OPENCV"
map_ba_global_function_tolerance: float = 0.000001
@gsplatstudio.register("colmap_with_cam-processor")
class ColmapWithCamProcessor(BaseDataProcessor):
def __init__(self, cfg, logger, source_path) -> None:
super().__init__(cfg, logger, source_path)
@property
def config_class(self):
return ColmapWithCamProcessorConfig
@property
def should_skip(self):
cameras_file = Path(self.source_path_str) / "sparse" / "0" / "cameras.bin"
images_file = Path(self.source_path_str) / "sparse" / "0" / "images.bin"
points3D_file = Path(self.source_path_str) / "sparse" / "0" / "points3D.bin"
return cameras_file.exists() and images_file.exists() and points3D_file.exists()
def run(self):
self.logger.info("Start running ColmapWithCamProcessorConfig...")
project_folder = Path(self.source_path_str) / "distorted"
project_folder.mkdir(parents=True, exist_ok=True)
database_path = Path(self.source_path_str) / "distorted" / "database.db"
image_distorted_folder = Path(self.source_path_str) / "input"
camera_folder = Path(self.source_path_str) / "camera"
## Feature extraction
feature_extractor_cmd = "colmap feature_extractor" + \
f" --database_path {str(database_path)}" + \
f" --image_path {str(image_distorted_folder)}" + \
f" --ImageReader.single_camera 1" + \
f" --ImageReader.camera_model {self.cfg.camera}" + \
f" --SiftExtraction.use_gpu {int(self.cfg.use_gpu)}"
exit_code = self.run_command_with_realtime_output(feature_extractor_cmd)
if exit_code != 0:
self.logger.error(f"Feature extraction failed with code {exit_code}. Exiting.")
exit(exit_code)
self.logger.info("Finish feature extraction...")
## Create points3D.txt
points3D_txt_path = project_folder / 'points3D.txt'
open(str(points3D_txt_path), 'w').close()
## Create camera.txt
camera_txt_path = project_folder / 'cameras.txt'
open(str(camera_txt_path), 'w').close()
unique_cameras = {}
camera_id = 1
for camera_file in camera_folder.glob('*.json'):
camera_data = load_json(camera_file)
intrinsics = camera_data['intrinsics']
| focal_length = fov_to_focal_length(intrinsics['fov'], intrinsics['width']) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ddjerqq/beam
# Path: src/types/user.py
class User:
id: int
username: str
avatar_url: str
# Path: src/types/video.py
class Video:
"""Tiktok video object"""
id: str
"""Unique identifier for the TikTok video. Also called "item_id"""
create_time: int
"""UTC Unix epoch (in seconds) of when the TikTok video was posted."""
cover_image_url: str
"""A CDN link for the video's cover image. The image is static. Due to our trust and safety policies, the link has a TTL of 6 hours."""
share_url: str
"""A shareable link for this TikTok video. Note that the website behaves differently on Mobile and Desktop devices."""
video_description: str
"""The description that the creator has set for the TikTok video. Max length: 150"""
duration: int
"""The duration of the TikTok video in seconds."""
height: int
"""The height of the TikTok video."""
width: int
"""The width of the TikTok video."""
title: str
"""The video title. Max length: 150"""
embed_html: str
"""HTML code for embedded video"""
embed_link: str
"""Video embed link of tiktok.com"""
like_count: int
"""Number of likes for the video"""
comment_count: int
"""Number of comments on the video"""
share_count: int
"""Number of shares of the video"""
view_count: int
"""Number of views of the video"""
@property
def create_timestamp(self) -> datetime.datetime:
return datetime.datetime.fromtimestamp(self.create_time, tz=datetime.UTC)
# Path: src/util.py
import os
import httpx
from src.types.user import User
from src.types.video import Video
def get_env(key: str, default: str = None) -> str:
"""
gets the environment variable with the given key,
or raises an exception if the default is not supplied.
"""
var = os.getenv("APP_ID", default)
if var is not None:
return var
raise Exception(f"Environment variable {key} not found.")
def humanize(num: int) -> str:
"""
converts a number to a human readable format.
"""
if num < 1000:
return str(num)
num = num / 1000
if num < 1000:
return f"{num:.1f}k"
num = num / 1000
if num < 1000:
return f"{num:.1f}m"
num = num / 1000
return f"{num:.1f}b"
| def video_info_to_webhook_payload(author: User, video: Video) -> dict[str, str]: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: onestepai/api_rag
# Path: src/config/ServiceApiConfig.py
class ServiceApiConfig(ServiceApiConfigBase):
def __init__(self):
ServiceApiConfigBase.__init__(self,
url_prefix=DockerConfig.URL_PREFIX + DockerConfig.API_VERSION,
version=DockerConfig.API_VERSION,
title=DockerConfig.API_TITLE,
description=DockerConfig.API_DESCRIPTION,
gpt_api_key= DockerConfig.GPT_API_KEY,
gpt_4_model= DockerConfig.GPT_API_VERSION_4,
gpt_3_5_model=DockerConfig.GPT_API_VERSION_35,
prompt_language=DockerConfig.PROMPT_LANGUAGE
)
self.__set_predict_request()
self.__set_predict_response()
def __set_predict_request(self):
request = ServiceApiConfigBase.api.model('PredictRequest.extractResult', {
'utterance': fields.String(description='content'),
'model_name': fields.String(description='model name'),
'language': fields.String(description='language')
})
predict_request = ServiceApiConfigBase.api.model('PredictRequest', {
'requestId': fields.String(description='request id'),
'request': fields.Nested(request, description='request'),
'timestamp': fields.Integer(description='calling timestamp')
})
ServiceApiConfigBase.predict_request = predict_request
def __set_predict_response(self):
response_result = ServiceApiConfigBase.api.model('PredictResponse.responseResult', {
'result': fields.String(description='result'),
'content': fields.String(description='content')
})
predict_response = ServiceApiConfigBase.api.model('PredictResponse', {
'requestId': fields.String(description='request id'),
'responseResult': fields.Nested(response_result, description='responseResult'),
'timestamp': fields.Integer(description='calling timestamp')
})
ServiceApiConfigBase.predict_response = predict_response
# Path: src/config/DockerConfig.py
class DockerConfig(object):
GPT_API_KEY = MyEnvironment().get_environment_variable("OPENAPI_API_KEY", 'Your open ai key')
API_VERSION = MyEnvironment().get_environment_variable("API_VERSION", '1.0')
GPT_API_VERSION_35 = MyEnvironment().get_environment_variable("GPT_3.5", 'gpt-3.5-turbo-1106')
GPT_API_VERSION_4 = MyEnvironment().get_environment_variable("GPT_4", 'gpt-4-1106-preview')
URL_PREFIX = MyEnvironment().get_environment_variable("URL_PREFIX", '/api_rag/')
SERVICE_PORT = MyEnvironment().get_environment_variable("PORT", '5000')
API_TITLE = MyEnvironment().get_environment_variable("API_TITLE", 'API RAG Service')
API_DESCRIPTION = MyEnvironment().get_environment_variable("API_DESCRIPTION", 'API RAG Service')
PROMPT_LANGUAGE = MyEnvironment().get_environment_variable("PROMPT_LANGUAGE", "zh_cn")
# Path: src/api_rag/ModelHandler.py
class ModelHandler(ModelBaseHandler):
V1 = "v1"
def __init__(self, config):
ModelBaseHandler.__init__(self, config)
self._version = ModelHandler.V1
self.create_model()
def create_model(self):
if self._version == ModelHandler.V1:
self._predictor = APIRAGModel()
def predict(self, request, **kwargs):
# try:
LoggerHelper().log_info(u"Request: " + str(request))
contents = request["request"]["content"]
data = json.loads(contents)
if "clean_context" in list(data.keys()):
final_result = "Reset successfully."
else:
text = data["utterance"]
model_name = data["model_name"]
LoggerHelper().log_info(u"date_text_content: " + str(text))
final_result = self._predictor.predict(text,model_name)
response_predict = self.create_predict_response(request,final_result)
if response_predict is not None:
return response_predict
def create_predict_response(self, request, predict_sent):
response = {
'requestId': request['requestId'] if 'requestId' in request else '',
'timestamp': time.time(),
'response': predict_sent
}
return {
'requestId': request['requestId'] if 'requestId' in request else '',
'timestamp': time.time(),
'responseResult': {
'result': 'success',
'content': json.dumps(response, ensure_ascii=False)
}
}
# Path: service.py
import logging
from src.config.ServiceApiConfig import ServiceApiConfig
from src.config.DockerConfig import DockerConfig
from src.api_rag.ModelHandler import ModelHandler
logging.getLogger().setLevel(logging.INFO)
logging.getLogger('boto3').setLevel(logging.CRITICAL)
logging.getLogger('botocore').setLevel(logging.CRITICAL)
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.INFO)
if __name__ == '__main__':
| config = ServiceApiConfig() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: DerwenAI/textgraphs
# Path: textgraphs/elem.py
class Edge:
"""
A data class representing an edge between two nodes.
"""
src_node: int
dst_node: int
kind: RelEnum
rel: str
prob: float
count: int = 1
# Path: textgraphs/elem.py
class Node: # pylint: disable=R0902
"""
A data class representing one node, i.e., an extracted phrase.
"""
node_id: int
key: str
span: typing.Union[ spacy.tokens.span.Span, spacy.tokens.token.Token ]
text: str
pos: str
kind: NodeEnum
loc: typing.List[ typing.List[ int ] ] = field(default_factory = lambda: [])
label: typing.Optional[ str ] = None
length: int = 1
sub_obj: bool = False
count: int = 0
neighbors: int = 0
weight: float = 0.0
entity: typing.List[ LinkedEntity ] = field(default_factory = lambda: [])
annotated: bool = False
def get_linked_label (
self
) -> typing.Optional[ str ]:
"""
When this node has a linked entity, return that IRI.
Otherwise return its `label` value.
returns:
a label for the linked entity
"""
if len(self.entity) > 0:
return self.entity[0].iri
return self.label
def get_name (
self
) -> str:
"""
Return a brief name for the graphical depiction of this Node.
returns:
brief label to be used in a graph
"""
if self.kind == NodeEnum.IRI:
return self.label # type: ignore
if self.kind == NodeEnum.LEM:
return self.key
return self.text
def get_stacked_count (
self
) -> int:
"""
Return a modified count, to redact verbs and linked entities from
the stack-rank partitions.
returns:
count, used for re-ranking extracted entities
"""
if self.pos == "VERB" or self.kind == NodeEnum.IRI:
return 0
return self.count
def get_pos (
self
) -> typing.Tuple[ int, int ]:
"""
Generate a position span for `OpenNRE`.
returns:
a position span needed for `OpenNRE` relation extraction
"""
position: typing.Tuple[ int, int ] = ( self.span.idx, self.span.idx + len(self.text) - 1, )
return position
# Path: textgraphs/elem.py
class NodeEnum (enum.IntEnum):
"""
Enumeration for the kinds of node categories
"""
DEP = 0 # `spaCy` parse dependency
LEM = 1 # lemmatized token
ENT = 2 # named entity
CHU = 3 # noun chunk
IRI = 4 # IRI for linked entity
def __str__ (
self
) -> str:
"""
Codec for representing as a string.
returns:
decoded string representation of the enumerated value
"""
decoder: typing.List[ str ] = [
"dep",
"lem",
"ent",
"chu",
"iri",
]
return decoder[self.value]
# Path: textgraphs/elem.py
class RelEnum (enum.IntEnum):
"""
Enumeration for the kinds of edge relations
"""
DEP = 0 # `spaCy` parse dependency
CHU = 1 # `spaCy` noun chunk
INF = 2 # `REBEL` or `OpenNRE` inferred relation
SYN = 3 # `sense2vec` inferred synonym
IRI = 4 # `DBPedia` or `Wikidata` linked entity
def __str__ (
self
) -> str:
"""
Codec for representing as a string.
returns:
decoded string representation of the enumerated value
"""
decoder: typing.List[ str ] = [
"dep",
"inf",
"syn",
"chu",
"iri",
]
return decoder[self.value]
# Path: textgraphs/graph.py
from collections import OrderedDict
from icecream import ic # pylint: disable=E0401
from .elem import Edge, Node, NodeEnum, RelEnum
import json
import typing
import networkx as nx # pylint: disable=E0401
import spacy # pylint: disable=E0401
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
This class implements a generic, in-memory graph data structure used
to represent the _lemma graph_.
see copyright/license https://huggingface.co/spaces/DerwenAI/textgraphs/blob/main/README.md
"""
######################################################################
## class definitions
class SimpleGraph:
"""
An in-memory graph used to build a `MultiDiGraph` in NetworkX.
"""
def __init__ (
self
) -> None:
"""
Constructor.
"""
self.nodes: typing.Dict[ str, Node ] = OrderedDict()
| self.edges: typing.Dict[ str, Edge ] = {} |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Noubissie237/StockManagment
# Path: StockManagment/App/utils.py
def panier_cookie(request):
articles = []
commande = {
'get_panier_total':0,
'get_panier_article':0,
'produit_physique': True,
}
nombre_article = commande['get_panier_article']
try:
panier = json.loads(request.COOKIES.get('panier'))
for obj in panier:
nombre_article += panier[obj]['qte']
produit = Produit.objects.get(id=obj)
total = produit.price * panier[obj]['qte']
commande['get_panier_article'] += panier[obj]['qte']
commande['get_panier_total'] += total
article = {
'produit': {
'pk': produit.id,
'name': produit.name,
'price': produit.price,
'nombre': produit.nombre
},
'quantite': panier[obj]['qte'],
'get_total': total
}
articles.append(article)
if produit.digital == False:
commande['produit_physique'] = True
except:
pass
context = {
'articles' : articles,
'commande': commande,
'nombre_article': nombre_article
}
return context
# Path: StockManagment/App/utils.py
def data_cookie(request):
if request.user.is_authenticated:
client = request.user.client
commande, created = Commande.objects.get_or_create(client=client, complete=False)
articles = commande.commandearticle_set.all()
nombre_article = commande.get_panier_article
else:
cookie_panier = panier_cookie(request)
articles = cookie_panier['articles']
commande = cookie_panier['commande']
nombre_article = cookie_panier['nombre_article']
context = {
'articles' : articles,
'commande': commande,
'nombre_article': nombre_article
}
return context
# Path: StockManagment/App/utils.py
def getDataFromApi(request):
try:
url = "http://localhost:8000/api/prescriptions/"
response = requests.get(url)
dataToSave = response.json()
for elt in dataToSave:
if not User.objects.filter(username=elt['email']).exists():
user = User.objects.create_user(username=elt['email'], email=elt['email'], password=elt['Token'])
user.save()
if Prescription.objects.filter(email=elt['email']).exists():
pass
else:
tmp = Prescription(nom=elt['nom'], prenom=elt['prenom'], age=elt['age'], sexe=elt['sexe'], email=elt['email'],
antecedent=elt['antecedent'], prescription1=elt['prescription1'], prescription2=elt['prescription2'],
prescription3=elt['prescription3'])
tmp.save()
try:
user = User.objects.get(username=elt['email'])
client = Client.objects.create(user=user, name=elt["nom"], email=elt['email'])
print("valid")
except:
print('invalid')
return "SUCCESS"
except:
return "FAILED"
# Path: StockManagment/App/forms.py
class LoginForm(forms.Form):
username = forms.CharField(label='Nom d\'utilisateur', widget=forms.TextInput(attrs={'class': 'form-control'}))
password = forms.CharField(label='Mot de passe', widget=PasswordInputWithClass())
# Path: StockManagment/App/views.py
from django.shortcuts import render, redirect
from django.http import JsonResponse, HttpResponse
from .models import *
from django.contrib.auth.decorators import login_required
from datetime import datetime
from .utils import panier_cookie, data_cookie, getDataFromApi
from .forms import LoginForm
from django.contrib.auth import authenticate, login, logout
import json, requests
@login_required(login_url='/login')
def shop(request, *args, **kwargs):
"""Vue des produits"""
produits = Produit.objects.all()
data = data_cookie(request)
articles = data['articles']
commande = data['commande']
nombre_article = data['nombre_article']
context = {
'produits': produits,
'nombre_article': nombre_article
}
return render(request, 'shop/index.html', context)
@login_required(login_url='/login')
def panier(request, *args, **kwargs):
data = data_cookie(request)
articles = data['articles']
commande = data['commande']
nombre_article = data['nombre_article']
context = {
'articles' : articles,
'commande': commande,
'nombre_article': nombre_article
}
return render(request, 'shop/panier.html', context)
@login_required(login_url='/login')
def commande(request, *args, **kwargs):
data = data_cookie(request)
articles = data['articles']
commande = data['commande']
nombre_article = data['nombre_article']
context = {
'articles' : articles,
'commande': commande,
'nombre_article': nombre_article
}
return render(request, 'shop/commande.html', context)
@login_required(login_url='/login')
def update_article(request, *args, **kwargs):
data = json.loads(request.body)
produit_id = data['produit_id']
action = data['action']
produit = Produit.objects.get(id=produit_id)
client = request.user.client
commande, created = Commande.objects.get_or_create(client=client, complete=False)
commande_article, created = CommandeArticle.objects.get_or_create(commande=commande, produit=produit)
if action == "add":
commande_article.quantite += 1
if action == "remove":
commande_article.quantite -=1
commande_article.save()
if commande_article.quantite <= 0:
commande_article.delete()
return JsonResponse("panier modifié", safe=False)
@login_required(login_url='/login')
def commandeAnonyme(request, data):
name = data['form']['name']
username = data['form']['username']
email = data['form']['email']
phone = data['form']['phone']
| cookie_panier = panier_cookie(request) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: kokiez/raydium-convert-SOLorTokens
# Path: pools.py
def fetch_pool_keys(mint: str):
amm_info = {}
all_pools = {}
try:
# Using this so it will be faster else no option, we go the slower way.
with open('all_pools.json', 'r') as file:
all_pools = json.load(file)
amm_info = extract_pool_info(all_pools, mint)
except:
resp = requests.get('https://api.raydium.io/v2/sdk/liquidity/mainnet.json', stream=True)
pools = resp.json()
official = pools['official']
unofficial = pools['unOfficial']
all_pools = official + unofficial
# Store all_pools in a JSON file
with open('all_pools.json', 'w') as file:
json.dump(all_pools, file, default=lambda x: x.__dict__)
amm_info = extract_pool_info(all_pools, mint)
return {
'amm_id': Pubkey.from_string(amm_info['id']),
'authority': Pubkey.from_string(amm_info['authority']),
'base_mint': Pubkey.from_string(amm_info['baseMint']),
'base_decimals': amm_info['baseDecimals'],
'quote_mint': Pubkey.from_string(amm_info['quoteMint']),
'quote_decimals': amm_info['quoteDecimals'],
'lp_mint': Pubkey.from_string(amm_info['lpMint']),
'open_orders': Pubkey.from_string(amm_info['openOrders']),
'target_orders': Pubkey.from_string(amm_info['targetOrders']),
'base_vault': Pubkey.from_string(amm_info['baseVault']),
'quote_vault': Pubkey.from_string(amm_info['quoteVault']),
'market_id': Pubkey.from_string(amm_info['marketId']),
'market_base_vault': Pubkey.from_string(amm_info['marketBaseVault']),
'market_quote_vault': Pubkey.from_string(amm_info['marketQuoteVault']),
'market_authority': Pubkey.from_string(amm_info['marketAuthority']),
'bids': Pubkey.from_string(amm_info['marketBids']),
'asks': Pubkey.from_string(amm_info['marketAsks']),
'event_queue': Pubkey.from_string(amm_info['marketEventQueue'])
}
# Path: pools.py
def make_simulate_pool_info_instruction(accounts):
keys = [
AccountMeta(pubkey=accounts["amm_id"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["authority"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["open_orders"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["base_vault"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["quote_vault"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["lp_mint"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts["market_id"], is_signer=False, is_writable=False),
AccountMeta(pubkey=accounts['event_queue'], is_signer=False, is_writable=False),
]
data = POOL_INFO_LAYOUT.build(
dict(
instruction=12,
simulate_type=0
)
)
return Instruction(AMM_PROGRAM_ID, data, keys)
# Path: main.py
from solana.rpc.commitment import Commitment
from solana.rpc.api import Client
from solana.transaction import Transaction
from solders.keypair import Keypair
from pools import fetch_pool_keys, make_simulate_pool_info_instruction
from ast import literal_eval
import re
LIQUIDITY_FEES_NUMERATOR = 25
LIQUIDITY_FEES_DENOMINATOR = 10000
"""
Required Variables
"""
endpoint = "your_rpc_url"
payer = Keypair.from_base58_string("your_private_key")
token = "ca of your mint/mint address"
solana_client = Client(endpoint, commitment=Commitment("confirmed"), blockhash_cache=True)
def calculateAmountOut(amount, pool_info):
status = pool_info['status']
SWAP_decimals = pool_info['coin_decimals'] #swap coin
SOL_decimals = pool_info['pc_decimals'] #SOL
COIN_lp_decimals = pool_info['lp_decimals'] #swap coin
pool_SOL_amount = pool_info['pool_pc_amount'] #sol
pool_SWAP_amount = pool_info['pool_coin_amount'] #coin
Coin_pool_lp_supply = pool_info['pool_lp_supply'] #coin
reserve_in = pool_SOL_amount
reserve_out = pool_SWAP_amount
current_price = reserve_out / reserve_in
# print(f"Current Price in SOL: {current_price:.12f}")
amount_in = amount * 10 ** SOL_decimals
Fees = (amount_in * LIQUIDITY_FEES_NUMERATOR)/LIQUIDITY_FEES_DENOMINATOR
amount_in_with_fee = amount_in - Fees
amountOutRaw = (reserve_out * amount_in_with_fee) / (reserve_in + amount_in_with_fee)
# Slippage = 1 + slippage
# minimumAmountOut = amountOutRaw / slippage
return amountOutRaw / 10 ** SWAP_decimals
def calculateAmountIn(amount, pool_info):
SWAP_decimals = pool_info['coin_decimals'] #swap coin
SOL_decimals = pool_info['pc_decimals'] #SOL
COIN_lp_decimals = pool_info['lp_decimals'] #swap coin
pool_SOL_amount = pool_info['pool_pc_amount'] #sol
pool_SWAP_amount = pool_info['pool_coin_amount'] #coin
Coin_pool_lp_supply = pool_info['pool_lp_supply'] #coin
reserve_in = pool_SWAP_amount
reserve_out = pool_SOL_amount
current_price = reserve_out / reserve_in
# print(f"Current Price in SOL: {current_price:.12f}")
amount_in = amount * 10 ** SWAP_decimals
Fees = (amount_in * LIQUIDITY_FEES_NUMERATOR)/LIQUIDITY_FEES_DENOMINATOR
amount_in_with_fee = amount_in - Fees
amountOutRaw = (reserve_out * amount_in_with_fee) / (reserve_in + amount_in_with_fee)
# Slippage = 1 + slippage
# minimumAmountOut = amountOutRaw / slippage
return amountOutRaw / 10 ** SOL_decimals
def PoolInfo(mint):
while True:
quote = ""
| pool_keys = fetch_pool_keys(mint)
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: proger/nanokitchen
# Path: structured_linear.py
class StructuredLinear(nn.Module):
def __init__(self, in_features, out_features, bias=True, device=None, dtype=None):
"""Subclasses should call reset_parameters
"""
factory_kwargs = {'device': device, 'dtype': dtype}
super().__init__()
self.in_features = in_features
self.out_features = out_features
# Subclasses may override {in,out}_features_extended
if not hasattr(self, 'in_features_extended'):
self.in_features_extended = in_features
if not hasattr(self, 'out_features_extended'):
self.out_features_extended = out_features
if bias:
self.bias = nn.Parameter(torch.zeros(out_features, **factory_kwargs))
else:
self.register_parameter('bias', None)
def reset_parameters(self) -> None:
self.set_weights_from_dense_init(dense_init_fn_=partial(init.kaiming_uniform_, a=math.sqrt(5)))
self.reset_parameters_bias()
def set_weights_from_dense_init(self, dense_init_fn_):
raise NotImplementedError
def reset_parameters_bias(self):
if self.bias is not None:
fan_in = self.bias.shape[-1]
bound = 1 / math.sqrt(fan_in) if fan_in > 0 else 0
init.uniform_(self.bias, -bound, bound)
@property
def saving(self):
raise NotImplementedError
def convert_to_dense_weight(self):
factory_kwargs = {'device': self.weight.device, 'dtype': self.weight.dtype}
dense_weight = self.forward_matmul(torch.eye(self.in_features, **factory_kwargs)).T
return dense_weight
def preprocess(self, x):
in_features = x.shape[-1]
if in_features < self.in_features_extended:
x = F.pad(x, (0, self.in_features_extended - in_features))
return x
def postprocess(self, output):
out_features_extended = output.shape[-1]
if out_features_extended > self.out_features:
output = output[..., :self.out_features]
return output
def forward_matmul(self, x):
raise NotImplementedError
def forward(self, x):
output = self.forward_matmul(x)
# Convert bias to output.dtype in case of AMP, otherwise bias and activation will be in FP32
return (output + self.bias.to(dtype=output.dtype)) if self.bias is not None else output
# Path: blockdiag_multiply.py
def blockdiag_weight_to_dense_weight(weight):
def blockdiag_multiply_reference(x, weight):
def forward(ctx, x, weight):
def backward(ctx, dout):
class BlockdiagMultiply(torch.autograd.Function):
# Path: blockdiag_linear.py
import math
import torch
import torch.nn as nn
from einops import rearrange
from structured_linear import StructuredLinear
from blockdiag_multiply import blockdiag_multiply
# Adapted from https://github.com/HazyResearch/fly/tree/master/src/models/layers
class BlockdiagLinear(StructuredLinear):
def __init__(self, *args, nblocks=4, shuffle=False, **kwargs):
"""shuffle: apply channel_shuffle operation before the matmul as in ShuffleNet
"""
super().__init__(*args, **kwargs)
in_blksz = int(math.ceil(self.in_features / nblocks))
out_blksz = int(math.ceil(self.out_features / nblocks))
self.in_features_extended = in_blksz * nblocks
self.out_features_extended = out_blksz * nblocks
self.shuffle = shuffle
self.weight = nn.Parameter(torch.empty(nblocks, out_blksz, in_blksz))
self.reset_parameters()
def set_weights_from_dense_init(self, dense_init_fn_):
dense_weight = torch.empty(self.out_features_extended, self.in_features_extended,
device=self.weight.device, dtype=self.weight.dtype)
dense_init_fn_(dense_weight)
# Scale by sqrt because the weight is sparse
scaling = math.sqrt(dense_weight.numel() / self.weight.numel())
dense_weight *= scaling
with torch.no_grad():
nblocks = self.weight.shape[0]
self.weight.copy_(rearrange(dense_weight, '(b o) (b1 i) -> b b1 o i',
b=nblocks, b1=nblocks)[0])
@property
def saving(self):
return self.weight.numel() / (self.in_features * self.out_features)
def forward_matmul(self, x):
x = self.preprocess(x)
if self.shuffle:
x = rearrange(x, '... (group c_per_group) -> ... (c_per_group group)',
group=self.weight.shape[0]) # group=nblocks
| output = blockdiag_multiply(x, self.weight) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: karloskar/homeassistant-goecontroller-mqtt
# Path: custom_components/goecontroller_mqtt/definitions/switch.py
SWITCHES: tuple[GoEControllerSwitchEntityDescription, ...] = (
GoEControllerSwitchEntityDescription(
key="tse",
name="Time server enabled",
entity_category=EntityCategory.CONFIG,
device_class=None,
entity_registry_enabled_default=False,
disabled=True,
disabled_reason="Not exposed via MQTT in firmware 053.1",
),
GoEControllerSwitchEntityDescription(
key="hsa",
name="HTTP STA authentication",
entity_category=EntityCategory.CONFIG,
device_class=None,
entity_registry_enabled_default=False,
disabled=True,
disabled_reason="Not exposed via MQTT in firmware 053.1",
),
GoEControllerSwitchEntityDescription(
key="cwe",
name="Cloud websocket enabled",
entity_category=EntityCategory.CONFIG,
device_class=None,
entity_registry_enabled_default=False,
disabled=True,
disabled_reason="Not exposed via MQTT in firmware 053.1",
),
)
# Path: custom_components/goecontroller_mqtt/definitions/switch.py
class GoEControllerSwitchEntityDescription(GoEControllerEntityDescription, SwitchEntityDescription):
"""Switch entity description for go-eController."""
domain: str = "switch"
payload_on: str = "true"
payload_off: str = "false"
optimistic: bool = False
# Path: custom_components/goecontroller_mqtt/entity.py
class GoEControllerEntity(Entity):
"""Common go-eController entity."""
def __init__(
self,
config_entry: config_entries.ConfigEntry,
description: GoEControllerEntityDescription,
) -> None:
"""Initialize the sensor."""
topic_prefix = config_entry.data[CONF_TOPIC_PREFIX]
serial_number = config_entry.data[CONF_SERIAL_NUMBER]
self._topic = f"{topic_prefix}/{serial_number}/{description.key}"
slug = slugify(self._topic.replace("/", "_"))
self.entity_id = f"{description.domain}.{slug}"
parsed_attribute = description.attribute
if isinstance(description.attribute, tuple):
parsed_attribute = "-".join(description.attribute)
self._attr_unique_id = "-".join(
[serial_number, description.domain, description.key, parsed_attribute]
)
self._attr_device_info = DeviceInfo(
identifiers={(DOMAIN, serial_number)},
name=config_entry.title,
manufacturer=DEVICE_INFO_MANUFACTURER,
model=DEVICE_INFO_MODEL,
)
# Path: custom_components/goecontroller_mqtt/switch.py
import logging
from homeassistant import config_entries, core
from homeassistant.components import mqtt
from homeassistant.components.switch import SwitchEntity
from homeassistant.core import callback
from .definitions.switch import SWITCHES, GoEControllerSwitchEntityDescription
from .entity import GoEControllerEntity
"""The go-eController (MQTT) switch."""
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(
hass: core.HomeAssistant,
config_entry: config_entries.ConfigEntry,
async_add_entities,
):
"""Config entry setup."""
async_add_entities(
GoEControllerSwitch(config_entry, description)
for description in SWITCHES
if not description.disabled
)
class GoEControllerSwitch(GoEControllerEntity, SwitchEntity):
"""Representation of a go-eController switch that is updated via MQTT."""
| entity_description: GoEControllerSwitchEntityDescription |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: T0kyoB0y/PotatoWidgets
# Path: PotatoWidgets/Variable/_Listener.py
class Listener(Variable):
def __init__(self, callback, initial_value=None):
super().__init__(initial_value)
self._callback = callback
self._thread = None
self._stop_thread = threading.Event()
self.start_listening()
def stop_listening(self):
if self._thread and self._thread.is_alive():
self._stop_thread.set()
self._thread.join()
def start_listening(self):
if self._thread and self._thread.is_alive():
print(f"{self} is already listening")
return
self._stop_thread.clear()
self._thread = threading.Thread(target=lambda: self._callback(self))
self._thread.start()
def get_value(self):
return self._value
def set_value(self, new_value):
self._value = new_value
self.emit("valuechanged")
def __str__(self):
return str(self._value)
# Path: PotatoWidgets/Variable/_Poll.py
class Poll(Variable):
def __init__(self, interval, callback, initial_value=None):
super().__init__(initial_value or callback())
self._interval = self._parse_interval(interval)
self._callback = callback
self._timeout_id = None
self.start_poll()
def _parse_interval(self, interval):
try:
if isinstance(interval, str):
unit = interval[-1].lower()
value = int(interval[:-1])
if unit == "s":
return value * 1000
elif unit == "m":
return value * 60 * 1000
elif unit == "h":
return value * 60 * 60 * 1000
elif isinstance(interval, int):
return interval
except (ValueError, IndexError):
return int(interval)
def is_polling(self):
return bool(self._timeout_id)
def stop_poll(self):
if self._timeout_id:
GLib.source_remove(self._timeout_id)
self._timeout_id = None
else:
print(f"{self} has no poll running")
def start_poll(self):
if self.is_polling():
print(f"{self} is already polling")
return
self._timeout_id = GLib.timeout_add(
priority=GLib.PRIORITY_DEFAULT_IDLE,
interval=self._interval,
function=self._poll_callback,
)
def _poll_callback(self):
self.set_value(self._callback())
return GLib.SOURCE_CONTINUE
def get_value(self):
return self._value
def set_value(self, new_value):
self._value = new_value
self.emit("valuechanged")
def __str__(self):
return str(self._value)
# Path: PotatoWidgets/Variable/_Variable.py
class Variable(GObject.Object):
valuechanged = GObject.Signal()
def __init__(self, initial_value):
super().__init__()
self._value = initial_value
def get_value(self):
return self._value
def set_value(self, new_value):
self._value = new_value
self.emit("valuechanged")
def initial_value(self, value):
self._value = value
def __str__(self):
return str(self._value)
# Path: PotatoWidgets/Widget/_Common/_BasicProps.py
from ...__Import import *
from ...Variable import Listener, Poll, Variable
class BasicProps(Gtk.Widget):
def __init__(
self,
halign,
valign,
hexpand,
vexpand,
active,
visible,
classname,
# tooltip,
css,
size=[10, 10],
):
Gtk.Widget.__init__(self)
self.set_hexpand(True if hexpand else False)
self.set_vexpand(True if vexpand else False)
self.set_halign(halign)
self.set_valign(valign)
self.set_visible(visible)
self.set_sensitive(active) if active is not None else None
self.set_classname(classname)
self.__clasif_size(size)
self.apply_css(css) if css else None
for key, value in locals().items():
callback = {
"halign": self.set_halign,
"valign": self.set_valign,
"hexpand": self.set_hexpand,
"vexpand": self.set_vexpand,
"active": self.set_sensitive,
"visible": self.set_visible,
"size": self.set_size,
"classname": self.set_classname,
}.get(key)
self.bind(value, callback) if callback else None
def set_size(self, size):
self.__clasif_size(size)
def set_halign(self, param):
super().set_halign(self.__clasif_align(str(param)))
def set_valign(self, param):
super().set_valign(self.__clasif_align(str(param)))
def __clasif_size(self, size):
if isinstance(size, int):
self.set_size_request(size, size)
elif isinstance(size, list):
if len(size) == 2:
self.set_size_request(size[0], size[1])
elif len(size) == 1:
self.set_size_request(size[0], size[0])
def __clasif_align(self, param):
dict = {
"fill": Gtk.Align.FILL,
"start": Gtk.Align.START,
"end": Gtk.Align.END,
"center": Gtk.Align.CENTER,
"baseline": Gtk.Align.BASELINE,
}
return dict.get(param.lower(), Gtk.Align.FILL)
def set_classname(self, param):
if isinstance(param, (str)):
context = self.get_style_context()
[context.add_class(i) for i in param.split(" ") if i != " "]
elif isinstance(param, (list)):
for i in param:
| if isinstance(i, (Listener, Variable, Poll)): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Zerohertz/Streamlit-Quant
# Path: lib/layout.py
def _main():
layout = _default()
layout.height = 500 * st.session_state["scale"]
layout.width = 1000
layout.xaxis = {
"type": "category",
"gridcolor": "black",
"tickangle": -45,
"tickfont": {"color": "black"},
"showgrid": True,
"tickmode": "auto",
"nticks": 20,
"rangeslider": {"visible": False},
}
layout.yaxis = {
"gridcolor": "black",
"tickprefix": "₩",
"tickformat": ",",
"tickfont": {"color": "black"},
"showgrid": True,
"autorange": True,
}
if not st.session_state["cache"]["vis_signals"]:
return layout
layout.yaxis2 = {
"overlaying": "y",
"side": "right",
"tickfont": {"color": "white"},
"showgrid": False,
}
layout.shapes = st.session_state["cache"]["transaction_vert"]
if st.session_state["cache"]["method"] != "Quant":
layout.yaxis3 = {
"overlaying": "y",
"side": "right",
"tickfont": {"color": "white"},
"showgrid": False,
}
return layout
# Path: lib/layout.py
def _transaction():
layout = _default()
layout.height = 400 * st.session_state["scale"]
layout.width = 1000
return layout
# Path: lib/util.py
def _color(cnt, alpha=0.99, palette="husl"):
colors = []
colors_ = zz.plot.color(cnt, uint8=True, palette=palette)
if cnt == 1:
colors_ = [colors_]
for color_ in colors_:
colors.append("rgba(" + ",".join(list(map(str, color_))) + f",{alpha})")
return colors
# Path: lib/visual.py
import plotly.graph_objs as go
import streamlit as st
import zerohertzLib as zz
from plotly.subplots import make_subplots
from lib.layout import _main, _transaction
from lib.util import _color
def candle():
data, xdata = st.session_state["cache"]["data"], st.session_state["cache"]["xdata"]
st.session_state["cache"]["candle"] = go.Candlestick(
x=xdata,
open=data.Open,
high=data.High,
low=data.Low,
close=data.Close,
increasing={"line": {"color": "red"}},
decreasing={"line": {"color": "blue"}},
name=st.session_state["cache"]["name"],
)
st.session_state["logger"].info(
f"""[Plot] Candle Chart: {st.session_state["cache"]["name"]} ({st.session_state["cache"]["symbol"]})"""
)
def moving_average():
xdata = st.session_state["cache"]["xdata"]
st.session_state["cache"]["ma"] = []
| colors = _color(4, 0.5, "Set1") |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: acman/py_june
# Path: posts/models.py
class Post(SlugModel):
title = models.CharField(max_length=50)
content = models.TextField(max_length=500, blank=True)
author = models.ForeignKey("users.ForumUser", on_delete=models.CASCADE)
category = models.ForeignKey("categories.Category", on_delete=models.CASCADE)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
is_active = models.BooleanField(default=True)
class Meta:
db_table = "posts"
verbose_name = "Post"
verbose_name_plural = "Posts"
ordering = ["-created_at"]
def __str__(self) -> str:
return self.title
# Path: comments/forms.py
class CommentForm(forms.ModelForm):
class Meta:
model = Comment
fields = ["title", "content"]
def __init__(self, *args: tuple, **kwargs: dict) -> None:
super(CommentForm, self).__init__(*args, **kwargs)
self.helper = FormHelper(self)
self.helper.form_method = "post"
self.helper.layout = Layout(
"title",
"content",
Submit(
"submit", "Create Comment", css_class="btn waves-effect waves-light"
),
)
self.field_order = ["title", "content"]
# Path: comments/models.py
class Comment(models.Model):
title = models.CharField(max_length=50)
content = models.TextField(max_length=500, blank=True)
author = models.ForeignKey("users.ForumUser", on_delete=models.CASCADE)
post = models.ForeignKey("posts.Post", on_delete=models.CASCADE)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
is_active = models.BooleanField(default=True)
class Meta:
db_table = "comments"
verbose_name = "Comment"
verbose_name_plural = "Comments"
ordering = ["-created_at"]
def __str__(self) -> str:
return self.title
# Path: comments/views.py
from django.contrib.auth.mixins import LoginRequiredMixin, UserPassesTestMixin
from django.http import HttpRequest, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.views import View
from posts.models import Post
from .forms import CommentForm
from .models import Comment
class CreateCommentView(LoginRequiredMixin, View):
template_name = "comments/comment_form.html"
login_url = "/users/login/"
def get(self, request: HttpRequest, post_slug: str) -> HttpResponse:
post = get_object_or_404(Post, slug=post_slug)
form = CommentForm()
return render(request, self.template_name, {"form": form, "post": post})
def post(self, request: HttpRequest, post_slug: str) -> HttpResponse:
form = CommentForm(request.POST)
post = get_object_or_404(Post, slug=post_slug)
if form.is_valid():
comment = form.save(commit=False)
comment.author = self.request.user
comment.post_id = post.pk
comment.save()
return redirect("categories:detail", category_slug=post.category.slug)
return render(request, self.template_name, {"form": form, "post": post})
class UpdateCommentView(UserPassesTestMixin, View):
template_name = "comments/comment_update.html"
def test_func(self) -> bool:
comment_pk = self.kwargs.get("comment_pk")
| comment = get_object_or_404(Comment, pk=comment_pk) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: pkariz/grin-explorer
# Path: backend/api/models.py
class Block(TimeStampedModel):
blockchain = models.ForeignKey(
Blockchain, related_name='blocks', on_delete=models.CASCADE)
hash = models.CharField(
primary_key=True,
max_length=64,
validators=[MinLengthValidator(64)],
db_index=True,
)
height = models.PositiveIntegerField(db_index=True)
timestamp = models.DateTimeField(db_index=True)
header = models.ForeignKey(
'BlockHeader', related_name='block', on_delete=models.CASCADE)
prev_hash = models.CharField(
max_length=64,
null=True,
blank=True,
validators=[MinLengthValidator(64)],
)
nr_inputs = models.PositiveIntegerField(default=0)
nr_outputs = models.PositiveIntegerField(default=0)
nr_kernels = models.PositiveIntegerField(default=0)
# when reorg is set it means this block is part of a reorg and not the main
# chain
reorg = models.ForeignKey(
'Reorg', null=True, related_name='blocks', on_delete=models.CASCADE)
def __str__(self):
suffix = ''
if self.reorg:
suffix = ' Reorged: {}'.format(self.reorg.id)
return '{}: {} (prev: {})'.format(
self.height, self.hash, self.prev_hash)
def get_next_block(self):
return Block.objects.filter(prev_hash=self.hash).first()
def get_previous_block(self):
return Block.objects.filter(hash=self.prev_hash).first()
def full_print(self, prefix=''):
"""Used for developing and debugging."""
print('---------------------------------------------------------------')
print(f'{prefix}Block {self.height}: {self.hash}, reorg: {self.reorg}')
print(f'{prefix} INPUTS:')
for input in self.inputs.all():
print(f'{prefix} {input}, output: {input.output}')
print(f'{prefix} OUTPUTS:')
for output in self.outputs.all():
print(f'{prefix} {output}')
print(f'{prefix} KERNELS:')
for kernel in self.kernels.all():
print(f'{prefix} {kernel}')
print('---------------------------------------------------------------')
# Path: backend/api/models.py
class Reorg(TimeStampedModel):
id = models.BigAutoField(primary_key=True)
blockchain = models.ForeignKey(
Blockchain, related_name='reorgs', on_delete=models.CASCADE)
# start_reorg_block and end_reorg_block define starting and ending block,
# which were reorged
start_reorg_block = models.ForeignKey(
Block, related_name='start_reorgs', on_delete=models.CASCADE)
end_reorg_block = models.ForeignKey(
Block, related_name='end_reorgs', on_delete=models.CASCADE)
# start_main_block defines starting block which is the new start of the main
# chain - the block that replaced start_reorg_block. We usually don't know
# which the ending block is when we spot the reorg, so we don't store it
# (we don't even have it in DB at that time yet since we usually get them
# incrementally in the order they're accepted).
start_main_block = models.ForeignKey(
Block, related_name='start_mains', on_delete=models.CASCADE)
def __str__(self):
return '{}: start: {}, end: {}'.format(
self.blockchain.slug, self.start_reorg_block, self.end_reorg_block)
# Path: backend/api/helpers.py
def fix_outputs_and_inputs_from_reorg(reorg):
"""
Fix Output.spent and Input.output on instances that were affected by the
given reorg. Note that due to the order of block fetching (sometimes
descending by height) we might have corrupted Output/Input instances also on
the reorged block. For example if block 102.1 in a reorg creates output with
commitment 'd' and the same commitment is created in block 102 but we first
fetch block 103 which spends it, then it will update output 'd' from 102.1
because it doesn't yet know that it's a part of a reorg (due to the way we
implemented things). We also need to fix outputs which were spent in a reorg
but not in the main chain and vice-versa.
"""
# solve reorged part
reorged_blocks = get_blocks_between(
reorg.start_reorg_block, reorg.end_reorg_block)
reorg_inputs = Input.objects.filter(block__in=reorged_blocks)
reorg_outputs = Output.objects.filter(block__in=reorged_blocks)
for output in reorg_outputs:
matching_input = reorg_inputs\
.filter(commitment=output.commitment)\
.first()
output.spent = False
if matching_input:
output.spent = True
matching_input.output = output
matching_input.save()
output.save()
# NOTE: some redundancy in this loop, but reorgs are rare so it's ok
for input in reorg_inputs:
matching_output = reorg_outputs\
.filter(commitment=input.commitment)\
.first()
if not matching_output:
# part of the main chain before the reorg happened, fix it there
matching_output = Output.objects.filter(
block__reorg=None, commitment=input.commitment).first()
if matching_output:
matching_output.spent = False
matching_output.save()
input.output = matching_output
input.save()
# solve main part
main_blocks = Block.objects\
.filter(height__gte=reorg.start_main_block.height, reorg=None)\
.order_by('height')
for block in main_blocks:
for input in block.inputs.all():
matching_output = Output.objects.filter(
block__reorg=None, commitment=input.commitment).first()
if matching_output:
matching_output.spent = True
matching_output.save()
input.output = matching_output
input.save()
# Path: backend/api/signals/receivers.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from backend.api.models import Block, Reorg
from backend.api.helpers import fix_outputs_and_inputs_from_reorg
import logging
logger = logging.getLogger(__name__)
@receiver(
post_save,
| sender=Block, |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: CodeWithEmad/num2fa
# Path: num2fa/constants.py
DEFAULT_SCIENTIFIC_SEPARATOR = " در ده به توان "
# Path: num2fa/constants.py
WORDS_DECIMAL_SEPARATOR = " و "
# Path: num2fa/constants.py
WORDS_FRACTION_SEPARATOR = " "
# Path: num2fa/constants.py
WORDS_NEGATIVE = "منفی "
# Path: num2fa/constants.py
ZERO = "صفر"
# Path: num2fa/utils.py
def _natural_words(str_num: str) -> str:
if str_num == "0":
return ZERO
length = len(str_num)
if length > len(CLASSES) * 3:
raise ValueError("out of range")
modulo_3 = length % 3
if modulo_3:
str_num = "0" * (3 - modulo_3) + str_num
length += 3 - modulo_3
groups = length // 3
group = groups
natural_words = ""
while group > 0:
three_digit = str_num[group * 3 - 3 : group * 3]
word3 = _three_digit_words(int(three_digit))
if word3 and group != groups:
if natural_words:
natural_words = (
word3
+ CLASSES[groups - group]
+ WORDS_DECIMAL_SEPARATOR
+ natural_words
)
else:
natural_words = word3 + CLASSES[groups - group]
else:
natural_words = word3 + natural_words
group -= 1
return natural_words
# Path: num2fa/utils.py
def _normalize_str(number: str) -> str:
"""Normalize the input number string."""
return str(number).strip().translate(NORMALIZATION_TABLE)
# Path: num2fa/utils.py
def _point_words(
number: str,
decimal_separator: str,
) -> str:
before_p, p, after_p = number.partition(".")
if after_p:
if before_p == "0":
if after_p == "0":
return ZERO
return _natural_words(after_p) + DECIMAL_PLACES[len(after_p)]
if after_p != "0":
return (
_natural_words(before_p)
+ decimal_separator
+ _natural_words(after_p)
+ DECIMAL_PLACES[len(after_p)]
)
return _natural_words(before_p)
return _natural_words(before_p)
# Path: num2fa/converters/word_converter.py
from decimal import Decimal
from fractions import Fraction
from functools import singledispatch
from typing import Union
from num2fa.constants import (
DEFAULT_SCIENTIFIC_SEPARATOR,
WORDS_DECIMAL_SEPARATOR,
WORDS_FRACTION_SEPARATOR,
WORDS_NEGATIVE,
ZERO,
)
from num2fa.utils import _natural_words, _normalize_str, _point_words
"""Provide functions to convert a number to Persian words."""
def _exp_words(
number: str,
positive: str,
negative: str,
decimal_separator: str,
scientific_separator: str,
) -> str:
# exponent
base, e, exponent = number.partition("e")
if exponent:
return (
_point_words(base, decimal_separator)
+ scientific_separator
+ words(int(exponent), positive, negative)
)
return _point_words(base, decimal_separator)
@singledispatch
def words(
number: Union[int, float, str, Decimal, Fraction],
positive: str = "",
negative: str = WORDS_NEGATIVE,
decimal_separator: str = WORDS_DECIMAL_SEPARATOR,
fraction_separator: str = WORDS_FRACTION_SEPARATOR,
ordinal_denominator: bool = True,
scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,
) -> str:
"""Return the word form of number.
If input is a string it should be in the form of a valid Python
representation for one of the other accepted types. The only exceptions are
that digits can be in Persian, for example words('۴۲') is valid.
"""
raise TypeError("invalid input type for words function", number)
@words.register(str)
@words.register(Decimal)
def _(
number: str,
positive: str = "",
negative: str = WORDS_NEGATIVE,
decimal_separator: str = WORDS_DECIMAL_SEPARATOR,
fraction_separator: str = WORDS_FRACTION_SEPARATOR,
ordinal_denominator: bool = True,
scientific_separator: str = DEFAULT_SCIENTIFIC_SEPARATOR,
) -> str:
# Normalize the number string
number = _normalize_str(number)
# sign
c0 = number[0]
if c0 == "-":
sign = negative
number = number[1:]
elif c0 == "0":
sign = ""
else:
sign = positive
numerator, e, denominator = number.partition("/")
if denominator:
if ordinal_denominator:
return (
sign
| + _natural_words(numerator) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: the-seeds/cardinal
# Path: src/cardinal/core/schema/extractor.py
class Extractor(ABC):
@abstractmethod
def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:
r"""
Loads the files into database.
Args:
input_files: a list of paths to input files.
user_id: the user id.
verbose: whether or not to show the process bar.
"""
...
# Path: src/cardinal/core/schema/leaf.py
class Leaf(LeafIndex):
content: str
# Path: src/cardinal/core/schema/leaf.py
class LeafIndex(BaseModel):
leaf_id: str = Field(default_factory=lambda: uuid.uuid4().hex)
user_id: str
# Path: src/cardinal/core/splitter/text_splitter.py
class CJKTextSplitter(TextSplitter):
def split(self, text: str) -> List[str]:
text = re.sub(r"\n{3,}", r"\n", text)
text = re.sub(r" {3,}", r" ", text)
text = re.sub(r"([。！？；])([^’”])", r"\1\n\2", text) # split with CJK stops
text = re.sub(r"(\…{2})([^’”])", r"\1\n\2", text) # split with CJK ellipsis
text = re.sub(r"([。！？；][’”]{0,2})([^，。！？；])", r"\1\n\2", text)
text = text.rstrip()
return super().split(text)
# Path: src/cardinal/core/extractor/base_extractor.py
import os
from multiprocessing import Pool
from pathlib import Path
from typing import TYPE_CHECKING, List, Optional
from tqdm import tqdm
from ..schema import Extractor, Leaf, LeafIndex
from ..splitter import CJKTextSplitter
from ..model import EmbedOpenAI
from ..schema import StringKeyedStorage, VectorStore
from ..model import EmbedOpenAI
from ..storage import RedisStorage
from ..vectorstore import Milvus
if TYPE_CHECKING:
class BaseExtractor(Extractor):
def __init__(
self, vectorizer: "EmbedOpenAI", storage: "StringKeyedStorage[Leaf]", vectorstore: "VectorStore[LeafIndex]"
) -> None:
self._vectorizer = vectorizer
self._storage = storage
self._vectorstore = vectorstore
self._splitter = CJKTextSplitter()
def load(self, input_files: List[Path], user_id: str, verbose: Optional[bool] = False) -> None:
file_contents: List[str] = []
for file_path in tqdm(input_files, desc="Extract content", disable=(not verbose)):
if file_path.suffix == ".txt":
with open(file_path, "r", encoding="utf-8") as f:
file_contents.append(f.read())
else:
raise NotImplementedError
text_chunks = []
with Pool(processes=int(os.environ.get("NUM_CPU_CORE"))) as pool:
for chunks in tqdm(
pool.imap_unordered(self._splitter.split, file_contents),
total=len(file_contents),
desc="Split content",
disable=(not verbose),
):
text_chunks.extend(chunks)
leaf_indexes = []
for chunk in tqdm(text_chunks, desc="Build index", disable=(not verbose)):
| leaf_index = LeafIndex(user_id=user_id) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: datrocity/pond
# Path: pond/conventions.py
METADATA_DIRNAME = '_pond'
# Path: pond/conventions.py
MANIFEST_FILENAME = 'manifest.yml'
# Path: pond/conventions.py
def version_data_location(version_location: str, data_filename: str) -> str:
return urijoinpath(version_location, data_filename)
# Path: pond/conventions.py
def version_manifest_location(version_location: str) -> str:
""" Manifest location with respect to a version root. """
return urijoinpath(version_location, METADATA_DIRNAME, MANIFEST_FILENAME)
# Path: pond/conventions.py
def version_uri(datastore_id: str, location: str, artifact_name: str, version_name: VersionName):
uri = f'pond://{datastore_id}/{location}/{artifact_name}/{str(version_name)}'
return uri
# Path: pond/conventions.py
def urijoinpath(*parts: str) -> str:
"""Joins two uri path components, also ensure the right part does not end with a slash"""
# TODO: use os.path.join
return '/'.join([part.rstrip('/') for part in parts])
# Path: pond/version_name.py
class SimpleVersionName(VersionName):
"""Simple version name are just an integer number (greater than 0) prefixed with "v" when
rendered as string."""
_FORMAT = re.compile('^v?([1-9][0-9]*)$')
# --- VersionName class interface
@classmethod
def from_string(cls, version_name: str) -> 'SimpleVersionName':
match = SimpleVersionName._FORMAT.match(version_name)
if not match:
raise InvalidVersionName(version_name)
return cls(int(match[1]))
@classmethod
def next(cls, prev: Optional['VersionName'] = None) -> VersionName:
if prev is None:
next_ = SimpleVersionName(1)
elif not isinstance(prev, SimpleVersionName):
raise IncompatibleVersionName(prev, SimpleVersionName)
else:
next_ = SimpleVersionName(prev.version_number + 1)
return next_
def __init__(self, version_number: int):
self.version_number = version_number
# -- VersionName protected interface
def _partial_compare(self, other: VersionName) -> Optional[int]:
if isinstance(other, SimpleVersionName):
return 0 if self.version_number == other.version_number else (
-1 if self.version_number < other.version_number else 1)
return None
# -- Magic methods
def __hash__(self) -> int:
return hash(self.version_number)
def __str__(self) -> str:
return f'v{self.version_number}'
# Path: tests/test_conventions.py
from pond.conventions import (
METADATA_DIRNAME,
MANIFEST_FILENAME,
version_data_location,
version_manifest_location,
version_uri,
urijoinpath,
)
from pond.version_name import SimpleVersionName
def test_urijoinpath():
joined = urijoinpath('a', 'b/', 'c/')
expected = 'a/b/c'
assert joined == expected
def test_data_location():
| location = version_data_location('abc/', 'blah.bin') |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Zitronenjoghurt/Colonaut
# Path: src/utils/file_operations.py
def construct_path(relative_path: str) -> str:
path_parts = relative_path.split("/")
absolute_path = os.path.join(ROOT_DIR, *path_parts)
return absolute_path
# Path: src/utils/file_operations.py
def files_in_directory(path: str, suffix: Optional[str] = None) -> list[str]:
if not os.path.exists(path):
raise ValueError(f"Directory {path} does not exist.")
files = []
for file in os.listdir(path):
if suffix is not None:
if suffix in file:
files.append(file)
else:
files.append(file)
return files
# Path: src/utils/file_operations.py
def file_to_dict(file_path: str) -> dict:
with open(file_path, 'r', encoding='utf-8') as f:
data = json.load(f)
if not isinstance(data, dict):
raise RuntimeError("Deserialized data is not a dictionary.")
return data
# Path: src/utils/file_operations.py
def str_to_file(file_path: str, string: str):
with open(file_path, 'w', encoding='utf-8') as f:
f.write(string)
# Path: src/constants/locales.py
class Locales:
# Common
FAILURE = "failure"
SUCCESS = "success"
# Descriptions
ACCELEROMETER_DESCRIPTION = "accelerometer_description"
BATTERY_DESCRIPTION = "battery_description"
HULL_DESCRIPTION = "hull_description"
INFRARED_SPECTROMETER_DESCRIPTION = "infrared_spectrometer_description"
LASER_ALTIMETER_DESCRIPTION = "laser_altimeter_description"
NEUTRON_DENSITOMETER_DESCRIPTION = "neutron_densitometer_description"
RADIO_TELEMETRY_DESCRIPTION = "radio_telemetry_description"
SOLAR_PANEL_DESCRIPTION = "solar_panel_description"
# Messages
BATTERY_CHARGED_BY = "battery_charged_by"
BATTERY_DISTRIBUTED_ENERGY = "battery_distributed_energy"
BATTERY_FULLY_CHARGED = "battery_fully_charged"
BATTERY_WARNING_NET_NEGATIVE_ENERGY = "battery_warning_net_negative_energy"
SOLAR_PANEL_COLLECTED_ENERGY = "solar_panel_collected_energy"
SOLAR_PANEL_NO_BATTERY = "solar_panel_no_battery"
# Names
ACCELEROMETER = "accelerometer"
BATTERY = "battery"
HULL = "hull"
INFRARED_SPECTROMETER = "infrared_spectrometer"
LASER_ALTIMETER = "laser_altimeter"
NEUTRON_DENSITOMETER = "neutron_densitometer"
RADIO_TELEMETRY = "radio_telemetry"
SOLAR_PANEL = "solar_panel"
# Science
DENSITY = "density"
MASS = "mass"
ORB_PERIOD = "orb_period"
RADIUS = "radius"
ROT_PERIOD = "rot_period"
TEMPERATURE = "temperature"
VOLUME = "volume"
# Stats
CAPACITY = "capacity"
CHARGE_CAPACITY = "charge_capacity"
HEALTH = "health"
MAX_CAPACITY = "max_capacity"
MAX_HP = "max_hp"
POWER = "power"
POWER_USAGE = "power_usage"
REVEAL_CHANCE = "reveal_chance"
SUCCESS_RATE = "success_rate"
# UI
ADDITIONAL_INFORMATION = "additional_information"
INSPIRED_BY_SEEDSHIP = "inspired_by_seedship"
OPTIONS = "options"
QUIT = "quit"
START_GAME = "start_game"
STATS = "stats"
@classmethod
def get_existing_keys(cls) -> list[str]:
return [getattr(cls, attr) for attr in dir(cls) if not callable(getattr(cls, attr)) and not attr.startswith("__")]
# Path: src/constants/locale_translator.py
from src.utils.file_operations import construct_path, files_in_directory, file_to_dict, str_to_file
from .locales import Locales
LOCALES_FILE_PATH = construct_path("src/data/locale/{language}/")
OUTPUT_TXT_FILE_PATH = construct_path("locale_{language}.txt")
LANGUAGES = ["en"]
class LocaleTranslator():
_instance = None
| KEYS = Locales |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: daojiAnime/aio_retrying
# Path: aio_retrying.py
class ConditionError(Exception):
pass
# Path: aio_retrying.py
def retry(
fn: Callable = None,
*,
attempts: int = 0,
callback: Optional[Callable] = None,
fallback: Union[Callable, Type[BaseException], Any] = None,
timeout: Union[int, float] = None,
delay: int = 0,
retry_exceptions: Tuple[Type[BaseException]] = (Exception,),
fatal_exceptions: Tuple[Type[BaseException]] = (asyncio.CancelledError,),
):
if fn is None:
return partial(
retry,
attempts=attempts,
callback=callback,
fallback=fallback,
timeout=timeout,
delay=delay,
retry_exceptions=retry_exceptions,
fatal_exceptions=fatal_exceptions,
)
@wraps(fn)
def wrapper(*args, **kwargs) -> Coroutine:
async def wrapped(attempt: int = 0) -> Any:
if not asyncio.iscoroutinefunction(fn):
raise ConditionError(
"Only support coroutine function",
)
if timeout is not None and asyncio.TimeoutError not in retry_exceptions:
_retry_exceptions = (asyncio.TimeoutError,) + retry_exceptions
else:
_retry_exceptions = retry_exceptions
try:
if timeout is None:
ret = await fn(*args, **kwargs)
else:
with async_timeout.timeout(timeout):
ret = await fn(*args, **kwargs)
return ret
except ConditionError:
raise
except fatal_exceptions:
raise
except _retry_exceptions as exc:
_attempts = "infinity" if attempts is forever else attempts
logger.debug(
exc.__class__.__name__ + f" -> Tried attempt {attempt} from total {attempts} for {fn}",
exc_info=exc,
)
if attempts is forever or attempt < attempts:
await asyncio.sleep(delay)
return await wrapped(attempt=attempt + 1)
ret = None
if fallback is not None:
if fallback is propagate:
raise exc
if is_exception(fallback):
raise fallback from exc
if callable(fallback):
if asyncio.iscoroutinefunction(fallback): # noqa
ret = await fallback(*args, **kwargs)
else:
ret = fallback(*args, **kwargs)
else:
ret = fallback
if callback is not None:
if not callable(callback):
raise ConditionError(
"Callback must be callable",
)
if asyncio.iscoroutinefunction(callback):
await callback(attempt, exc, args, kwargs)
else:
callback(attempt, exc, args, kwargs)
return ret
return wrapped()
return wrapper
# Path: tests/test_condition_error.py
import asyncio
import pytest
from aio_retrying import ConditionError, retry
async def test_timeout_is_not_none_and_not_async():
@retry(timeout=0.5)
def not_coro():
pass
| with pytest.raises(ConditionError): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: xIMRANx/secret_postcard
# Path: app/db/functions.py
class User(models.User):
@classmethod
async def is_registered(cls, telegram_id: int) -> Union[models.User, bool]:
try:
return await cls.get(telegram_id=telegram_id)
except DoesNotExist:
return False
@classmethod
async def is_admin(cls, telegram_id: int) -> bool:
user = await cls.is_registered(telegram_id)
if not user:
return False
if user.role == "admin":
return True
else:
return False
@classmethod
async def register(cls, telegram_id: int, name: str = None) -> None:
await User(
telegram_id=telegram_id, name=name, create_date=datetime.now()
).save()
@classmethod
async def get_count(cls) -> int:
return await cls.all().count()
@classmethod
async def edit_anonymous(cls, user_id: int, anonymous: bool) -> None:
await cls.filter(telegram_id=user_id).update(anonymous=anonymous)
@classmethod
async def get_all_users(cls) -> list[models.User]:
return await cls.all()
# Path: app/db/functions.py
class Card(models.Card):
@classmethod
async def get_all_card_owners(cls) -> list[models.Card]:
return await cls.filter(approved=True).values_list("owner_id", flat=True)
@classmethod
async def get_count(cls) -> int:
return await cls.all().count()
@classmethod
async def create_card(
cls, file_id: str, description: str, owner_id: int, file_type: str = "photo"
) -> None:
await Card(
file_id=file_id,
description=description,
owner_id=owner_id,
file_type=file_type,
create_date=datetime.now(),
).save()
@classmethod
async def check_exists(cls, user_id: int) -> bool:
return await cls.filter(owner_id=user_id).exists()
@classmethod
async def approve(cls, user_id: int) -> None:
await cls.filter(owner_id=user_id).update(approved=True)
@classmethod
async def get_card(cls, user_id: int) -> Union[models.Card, bool]:
try:
return await cls.get(owner_id=user_id, approved=False)
except DoesNotExist:
return False
@classmethod
async def delete_card(cls, user_id: int) -> None:
await cls.filter(owner_id=user_id).delete()
@classmethod
async def get_all_cards(cls) -> list[models.Card]:
return await cls.filter(approved=True).all()
# Path: app/keyboards/inline.py
def get_approve_keyboard(user_id):
buttons = [
[InlineKeyboardButton(text="✅", callback_data=f"approve:{user_id}")],
[InlineKeyboardButton(text="❌", callback_data=f"decline:{user_id}")],
]
keyboard = InlineKeyboardBuilder(markup=buttons)
return keyboard.as_markup()
# Path: app/config.py
class Config:
bot: ConfigBot
database: ConfigDatabase
settings: ConfigSettings
api: ConfigApi
@classmethod
def parse(cls, data: dict) -> "Config":
sections = {}
for section in fields(cls):
pre = {}
current = data[section.name]
for field in fields(section.type):
if field.name in current:
pre[field.name] = current[field.name]
elif field.default is not MISSING:
pre[field.name] = field.default
else:
raise ValueError(
f"Missing field {field.name} in section {section.name}"
)
sections[section.name] = section.type(**pre)
return cls(**sections)
# Path: app/handlers/user/file.py
from aiogram import Router, Bot, F
from aiogram.types import Message
from app.db.functions import User
from app.db.functions import Card
from app.keyboards.inline import get_approve_keyboard
from app.config import Config
router = Router()
@router.message(F.content_type.in_({"photo", "video", "animation"}))
async def get_postcard(message: Message, bot: Bot, config: Config):
if await Card.check_exists(message.from_user.id):
await message.answer("Вы уже отправили свою открытку!")
return
postcard_type = message.content_type
if message.photo is not None:
file_id = message.photo[-1].file_id
elif message.video is not None:
file_id = message.video.file_id
elif message.animation is not None:
file_id = message.animation.file_id
else:
file_id = None
user_id = message.from_user.id
chat_id = config.settings.chat_id
| if not await User.is_registered(user_id): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: akkoaya/ArticleSpider
# Path: ArticleSpider/items.py
class CnblogItem(scrapy.Item):
url = scrapy.Field()
url_object_id = scrapy.Field()
title = scrapy.Field()
date = scrapy.Field()
writer_id = scrapy.Field()
views_num = scrapy.Field()
comments_num = scrapy.Field()
main_content = scrapy.Field()
def save_to_es(self):
cnblog = CnblogPost()
cnblog.url = self['url'][0]
cnblog.meta.id = self['url_object_id'][0] #设置index的id为url_object_id
cnblog.title = self['title'][0]
cnblog.date = self['date'][0]
cnblog.writer_id = self['writer_id'][0]
cnblog.views_num = self['views_num'][0]
cnblog.comments_num = self['comments_num'][0]
cnblog.main_content = remove_tags(self['main_content'][0])
cnblog.suggest = get_suggests("cnblog",((cnblog.title, 10),)) #注意set里面只有一个元素的时候必须加个逗号，不然不计算该元素
cnblog.save() #保存
redis_cli.incr('cnblog_nums')
return
def get_insert_sql(self):
insert_sql = """
insert into cnblog(url_object_id,url,title,date,writer_id,views_num,comments_num,main_content,)
values(%s,%s,%s,%s,%s,%s,%s,%s)
"""
params = (
self["url_object_id"][0], self["url"][0], self['title'][0],
self['date'][0], self['writer_id'][0], self['views_num'][0],
self['comments_num'][0],self['main_content'][0]
)
return insert_sql, params
# Path: ArticleSpider/utils/common.py
def get_md5(url):
m = hashlib.md5()
m.update(url.encode("utf-8"))
return m.hexdigest()
# Path: scrapy_redis/spiders.py
class RedisSpider(RedisMixin, Spider):
"""Spider that reads urls from redis queue when idle.
Attributes
----------
redis_key : str (default: REDIS_START_URLS_KEY)
Redis key where to fetch start URLs from..
redis_batch_size : int (default: CONCURRENT_REQUESTS)
Number of messages to fetch from redis on each attempt.
redis_encoding : str (default: REDIS_ENCODING)
Encoding to use when decoding messages from redis queue.
Settings
--------
REDIS_START_URLS_KEY : str (default: "<spider.name>:start_urls")
Default Redis key where to fetch start URLs from..
REDIS_START_URLS_BATCH_SIZE : int (deprecated by CONCURRENT_REQUESTS)
Default number of messages to fetch from redis on each attempt.
REDIS_START_URLS_AS_SET : bool (default: False)
Use SET operations to retrieve messages from the redis queue. If False,
the messages are retrieve using the LPOP command.
REDIS_ENCODING : str (default: "utf-8")
Default encoding to use when decoding messages from redis queue.
"""
@classmethod
def from_crawler(cls, crawler, *args, **kwargs):
obj = super(RedisSpider, cls).from_crawler(crawler, *args, **kwargs)
obj.setup_redis(crawler)
return obj
# Path: ArticleSpider/spiders/cnblog.py
import scrapy
import datetime
import re
from scrapy.http import Request
from urllib import parse
from ..items import CnblogItem
from ..utils.common import get_md5
from scrapy.loader import ItemLoader
from scrapy_redis.spiders import RedisSpider
class CnblogSpider(scrapy.Spider):
name = "cnblog"
allowed_domains = ["www.cnblogs.com"]
start_urls = ["https://www.cnblogs.com/sitehome/p/1"]
# redis_key = 'cnblog:start_urls'
next_url = "https://www.cnblogs.com/sitehome/p/{0}"
# headers = {
# "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
# }
def parse(self, response):
all_urls = response.css('div.post-list a::attr(href)').extract()
all_urls = [parse.urljoin(response.url, url) for url in all_urls]
for url in all_urls:
match_obj = re.match('(.*.cnblogs.com/(.*)/p/.*.html)',url)
if match_obj:
request_url = match_obj.group(1)
writer_id = match_obj.group(2)
yield Request(url=request_url,meta={'writer_id':writer_id},callback=self.parse_detail)
for x in range(2,100):
yield Request(url=self.next_url.format(x), callback=self.parse)
def parse_detail(self,response):
item_loader = ItemLoader(item=CnblogItem(), response=response)
item_loader.add_value("url", response.url)
| item_loader.add_value("url_object_id", get_md5(response.url)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Asa-Nisi-Masa/christmas-tree
# Path: christmas_tree/common/settings.py
PATH_SAVE = "coordinates.csv"
# Path: christmas_tree/common/settings.py
TOTAL_LEDS = 500
# Path: christmas_tree/calculations/compute_coords.py
from collections import defaultdict, namedtuple
from pathlib import Path
from typing import Dict, List, Optional
from tqdm import tqdm
from christmas_tree.common.settings import PATH_SAVE, TOTAL_LEDS
import cv2
import numpy as np
contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
centers = []
for contour in contours:
M = cv2.moments(contour)
if M["m00"] != 0:
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
centers.append(Point(cX, cY))
return centers
def _compute_correct_positions(contour_centers: List[Point]) -> Optional[Point]:
if len(contour_centers) == 0:
return None
if len(contour_centers) == 1:
return contour_centers[0]
min_dist = float("inf")
for i in range(len(contour_centers)):
for j in range(i, len(contour_centers)):
if i == j:
continue
xi, yi = contour_centers[i]
xj, yj = contour_centers[j]
dist2 = (xi - xj) ** 2 + (yi - yj) ** 2
if dist2 < min_dist:
min_dist = dist2
if min_dist < MAX_DIST**2:
centers = np.array(contour_centers).mean(axis=0)
return Point(int(centers[0]), int(centers[1]))
return None
def _get_map_from_index_to_position(angle: int) -> Dict[int, Point]:
map_index_to_position = {}
total_errors = 0
for i in range(TOTAL_LEDS):
path = Path("frames") / str(angle) / f"{i}.jpg"
frame = cv2.imread(str(path))
contour_centers = _compute_naive_positions(frame)
center = _compute_correct_positions(contour_centers)
if center is None:
total_errors += 1
map_index_to_position[i] = None
else:
map_index_to_position[i] = _get_uv(center, width, height)
return map_index_to_position
def get_map_index_to_angle_position() -> Dict[int, Dict[int, Point]]:
# map_index_to_angle_position = map from LED index to a map from angle to LED position
angles_to_centers = {}
map_index_to_angle_position = defaultdict(dict)
for angle in tqdm(ANGLES):
map_index_to_position = _get_map_from_index_to_position(angle)
angles_to_centers[angle] = map_index_to_position
for i in range(TOTAL_LEDS):
map_index_to_angle_position[i][angle] = map_index_to_position[i]
return map_index_to_angle_position
def validate_led_positions(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> None:
total_no_centers = 0
for i in range(TOTAL_LEDS):
num_angles_center_is_defined = sum(el is not None for el in map_index_to_angle_position[i].values())
if num_angles_center_is_defined < 1:
print(f"No center can be found for {i} LED")
total_no_centers += 1
print("Total no LED positions found:", total_no_centers)
def get_frames_to_xyz(map_index_to_angle_position: Dict[int, Dict[int, Point]]) -> Dict[int, tuple]:
# frames_to_xyz = map from LED index to LED position
frames_to_xyz = {}
for i in range(TOTAL_LEDS):
sum_x = 0
sum_z = 0
sum_y = 0
non_nulls = 0
for angle in ANGLES:
radian = np.pi / 180 * angle
center = map_index_to_angle_position[i][angle]
if center is not None:
sum_x += center.x * np.cos(radian)
sum_z += center.x * np.sin(radian)
sum_y += center.y
non_nulls += 1
if non_nulls > 0:
x = 1 / non_nulls * sum_x
z = 1 / non_nulls * sum_z
y = 1 / non_nulls * sum_y
frames_to_xyz[i] = (x, y, z)
else:
frames_to_xyz[i] = None
return frames_to_xyz
def save_to_file(frames_to_xyz: Dict[int, tuple]):
| with open(PATH_SAVE, "w") as file: |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: YYJeffrey/july_server
# Path: app/lib/token.py
def verify_token(token):
def generate_token(user_id):
# Path: app/model/base.py
class BaseModel(db.Model):
def __getitem__(self, key):
def init_on_load(self):
def __set_fields(self):
def _set_fields(self):
def keys(self):
def hide(self, *keys):
def append(self, *keys):
def status(self):
def get_or_404(cls, **kwargs):
def all_or_404(cls, **kwargs):
def get_one(cls, **kwargs):
def get_all(cls, **kwargs):
def create(cls, commit: bool = True, **kwargs):
def update(self, commit: bool = True, **kwargs):
def save(self, commit: bool = True):
def delete(self, commit: bool = True, soft: bool = True):
def get_pagination(cls, not_del: bool = True, **kwargs):
# Path: app/lib/exception.py
class Success(APIException):
code = 200
msg_code = 0
msg = '成功'
# Path: app/lib/exception.py
class Updated(APIException):
code = 200
msg_code = 2
msg = '更新成功'
# Path: app/lib/red_print.py
class RedPrint(object):
"""
红图用于嵌套路由使用
"""
def __init__(self, name):
self.name = name
self.mound = []
def route(self, rule, **options):
def decorator(func):
if 'strict_slashes' not in options:
options['strict_slashes'] = False
self.mound.append((func, rule, options))
return func
return decorator
def register(self, bp, url_prefix=None):
if url_prefix is None:
url_prefix = f"/{self.name}"
for func, rule, options in self.mound:
endpoint = f"{self.name}/{options.pop('endpoint', func.__name__)}"
bp.add_url_rule(url_prefix + rule, endpoint, func, **options)
# Path: app/model/message.py
class Message(BaseModel):
"""
消息模型
"""
__tablename__ = 'message'
content = Column(String(256), nullable=False, comment='内容')
category = Column(Enum(MessageCategory), default=MessageCategory.COMMENT, comment='类型')
is_read = Column(Boolean, default=False, comment='是否已读')
is_anon = Column(Boolean, default=False, comment='是否匿名')
user_id = Column(String(32), nullable=False, index=True, comment='用户标识')
action_user_id = Column(String(32), nullable=False, index=True, comment='发起用户标识')
topic_id = Column(String(32), index=True, comment='话题标识')
def __str__(self):
return self.content
def _set_fields(self):
self.append('push_time')
self._exclude.extend(['action_user_id'])
@property
def push_time(self):
"""
发布时间
"""
if self.create_time is not None:
return datetime_to_hint(self.create_time)
return None
# Path: app/service/message.py
def get_message_list():
"""
查询消息列表
"""
action_user = aliased(User)
data = db.session.query(Message, User, action_user, Topic) \
.outerjoin(User, Message.user_id == User.id) \
.outerjoin(action_user, Message.action_user_id == action_user.id) \
.outerjoin(Topic, Message.topic_id == Topic.id) \
.filter(Message.user_id == g.user.id) \
.filter(Message.is_read.is_(False)) \
.filter(Message.delete_time.is_(None)) \
.all()
for index, (message, _, message.action_user, message.topic) in enumerate(data):
if message.topic is not None:
if message.topic.is_anon and g.user.id != message.topic.user_id:
message.topic.user = None
else:
message.topic.user = User.get_one(id=message.topic.user_id)
if message.topic.video_id is not None:
message.topic.video = Video.get_one(id=message.topic.video_id)
else:
message.topic.video = None
message.topic.append('user', 'video')
if message.is_anon:
message.action_user = None
message.append('action_user', 'topic')
data[index] = message
return data
# Path: app/api/v2/message.py
from flask import g
from app import auth, db
from app.lib.exception import Success, Updated
from app.lib.red_print import RedPrint
from app.model.message import Message
from app.service.message import get_message_list
# -*- coding: utf-8 -*-
"""
:copyright: (c) 2023 by Jeffrey.
:license: Apache 2.0, see LICENSE for more details.
"""
api = RedPrint('message')
@api.route('/', methods=['GET'])
@auth.login_required
def get_messages():
"""
获取消息
"""
messages = get_message_list()
return Success(data=messages)
@api.route('/read', methods=['POST'])
@auth.login_required
def read_messages():
"""
已读信息
"""
with db.auto_commit():
db.session.query(Message).filter_by(user_id=g.user.id, is_read=False).update({Message.is_read: True})
| return Updated() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: lchen1019/Image_Cropper
# Path: ISAT/annotation.py
class Object:
def __init__(self, category:str, group:int, segmentation, area, layer, bbox, iscrowd=0, note=''):
self.category = category
self.group = group
self.segmentation = segmentation
self.area = area
self.layer = layer
self.bbox = bbox
self.iscrowd = iscrowd
self.note = note
# Path: ISAT/configs.py
class STATUSMode(Enum):
VIEW = 0
CREATE = 1
EDIT = 2
# Path: ISAT/configs.py
class CLICKMode(Enum):
POSITIVE = 0
NEGATIVE = 1
# Path: ISAT/configs.py
class DRAWMode(Enum):
POLYGON = 0
SEGMENTANYTHING = 1
# Path: ISAT/configs.py
class CONTOURMode(Enum):
SAVE_MAX_ONLY = 0 # 只保留最多顶点的mask（一般为最大面积）
SAVE_EXTERNAL = 1 # 只保留外轮廓
SAVE_ALL = 2 # 保留所有轮廓
# Path: ISAT/widgets/polygon.py
from PyQt5 import QtCore, QtWidgets, QtGui
from ISAT.annotation import Object
from ISAT.configs import STATUSMode, CLICKMode, DRAWMode, CONTOURMode
import typing
# -*- coding: utf-8 -*-
# @Author : LG
class PromptPoint(QtWidgets.QGraphicsPathItem):
def __init__(self, pos, type=0):
super(PromptPoint, self).__init__()
self.color = QtGui.QColor('#0000FF') if type==0 else QtGui.QColor('#00FF00')
self.color.setAlpha(255)
self.painterpath = QtGui.QPainterPath()
self.painterpath.addEllipse(
QtCore.QRectF(-1, -1, 2, 2))
self.setPath(self.painterpath)
self.setBrush(self.color)
self.setPen(QtGui.QPen(self.color, 3))
self.setZValue(1e5)
self.setPos(pos)
class Vertex(QtWidgets.QGraphicsPathItem):
def __init__(self, polygon, color, nohover_size=2):
super(Vertex, self).__init__()
self.polygon = polygon
self.color = color
self.color.setAlpha(255)
self.nohover_size = nohover_size
self.hover_size = self.nohover_size + 2
self.line_width = 0
self.nohover = QtGui.QPainterPath()
self.nohover.addEllipse(QtCore.QRectF(-self.nohover_size//2, -self.nohover_size//2, self.nohover_size, self.nohover_size))
self.hover = QtGui.QPainterPath()
self.hover.addRect(QtCore.QRectF(-self.nohover_size//2, -self.nohover_size//2, self.nohover_size, self.nohover_size))
self.setPath(self.nohover)
self.setBrush(self.color)
self.setPen(QtGui.QPen(self.color, self.line_width))
self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsSelectable, True)
self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemIsMovable, True)
self.setFlag(QtWidgets.QGraphicsItem.GraphicsItemFlag.ItemSendsGeometryChanges, True)
self.setAcceptHoverEvents(True)
self.setZValue(1e5)
def setColor(self, color):
self.color = QtGui.QColor(color)
self.color.setAlpha(255)
self.setPen(QtGui.QPen(self.color, self.line_width))
self.setBrush(self.color)
def itemChange(self, change: 'QtWidgets.QGraphicsItem.GraphicsItemChange', value: typing.Any):
if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemSelectedHasChanged:
self.scene().mainwindow.actionDelete.setEnabled(self.isSelected())
if self.isSelected():
selected_color = QtGui.QColor('#00A0FF')
self.setBrush(selected_color)
else:
self.setBrush(self.color)
if change == QtWidgets.QGraphicsItem.GraphicsItemChange.ItemPositionChange and self.isEnabled():
# 限制顶点移动到图外
if value.x() < 0:
value.setX(0)
if value.x() > self.scene().width()-1:
value.setX(self.scene().width()-1)
if value.y() < 0:
value.setY(0)
if value.y() > self.scene().height()-1:
value.setY(self.scene().height()-1)
index = self.polygon.vertexs.index(self)
self.polygon.movePoint(index, value)
return super(Vertex, self).itemChange(change, value)
def hoverEnterEvent(self, event: 'QGraphicsSceneHoverEvent'):
| if self.scene().mode == STATUSMode.CREATE: # CREATE |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: aoki-h-jp/crypto-listed-detector
# Path: crypto_listed_detector/fetchapi/binance.py
class BinanceFetch:
_BASE_URL = "https://fapi.binance.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/fapi/v1/exchangeInfo"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_ticker()["symbols"]]
# Path: crypto_listed_detector/fetchapi/bitget.py
class BitgetFetch:
_BASE_URL = "https://api.bitget.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/api/v2/mix/market/tickers?productType=USDT-FUTURES"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_ticker()["data"]]
# Path: crypto_listed_detector/fetchapi/bybit.py
class BybitFetch:
_BASE_URL = "https://api.bybit.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/v5/market/tickers?category=linear"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_ticker()["result"]["list"]]
# Path: crypto_listed_detector/fetchapi/gateio.py
class GateioFetch:
_BASE_URL = "https://api.gateio.ws"
def __init__(self):
pass
def get_contracts(self):
url = self._BASE_URL + "/api/v4/futures/usdt/contracts"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["name"] for item in self.get_contracts()]
# Path: crypto_listed_detector/fetchapi/kucoin.py
class KucoinFetch:
_BASE_URL = "https://api-futures.kucoin.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/api/v1/contracts/active"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_ticker()["data"]]
# Path: crypto_listed_detector/fetchapi/mexc.py
class MexcFetch:
_BASE_URL = "https://contract.mexc.com"
def __init__(self):
pass
def get_risk_reverse(self):
url = self._BASE_URL + "/api/v1/contract/risk_reverse"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_risk_reverse()["data"]]
# Path: crypto_listed_detector/fetchapi/okx.py
class OkxFetch:
_BASE_URL = "https://www.okx.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/api/v5/public/instruments?instType=SWAP"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["instId"] for item in self.get_linear_ticker()["data"]]
# Path: crypto_listed_detector/fetchapi/phemex.py
class PhemexFetch:
_BASE_URL = "https://api.phemex.com"
def __init__(self):
pass
def get_linear_products(self):
url = self._BASE_URL + "/public/products"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [
item["symbol"] for item in self.get_linear_products()["data"]["products"]
]
# Path: crypto_listed_detector/fetchapi/pionex.py
class PionexFetch:
_BASE_URL = "https://api.pionex.com"
def __init__(self):
pass
def get_linear_symbols(self):
url = self._BASE_URL + "/api/v1/common/symbols"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_symbols()["data"]["symbols"]]
# Path: crypto_listed_detector/fetchapi/xtcom.py
class XtcomFetch:
_BASE_URL = "https://fapi.xt.com"
def __init__(self):
pass
def get_linear_ticker(self):
url = self._BASE_URL + "/future/market/v1/public/cg/contracts"
response = requests.get(url)
return response.json()
def get_all_linear_symbols(self):
return [item["symbol"] for item in self.get_linear_ticker()]
# Path: crypto_listed_detector/detector.py
import json
from crypto_listed_detector.fetchapi.binance import BinanceFetch
from crypto_listed_detector.fetchapi.bitget import BitgetFetch
from crypto_listed_detector.fetchapi.bybit import BybitFetch
from crypto_listed_detector.fetchapi.gateio import GateioFetch
from crypto_listed_detector.fetchapi.kucoin import KucoinFetch
from crypto_listed_detector.fetchapi.mexc import MexcFetch
from crypto_listed_detector.fetchapi.okx import OkxFetch
from crypto_listed_detector.fetchapi.phemex import PhemexFetch
from crypto_listed_detector.fetchapi.pionex import PionexFetch
from crypto_listed_detector.fetchapi.xtcom import XtcomFetch
"""
crypto-listed-detector
"""
class Detector:
def __init__(self):
"""
Init all fetchers
"""
| self.bybit = BybitFetch() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: harvestingmoon/StableVisionBot
# Path: backend.py
class BackEnd:
def __init__(self,model_id) -> None:
self.model = None
self.curr_picture = None
self.final_img = None
self.call = {1:False,2:False}
self.model_id = (model_id if model_id else "stabilityai/stable-diffusion-2")
def change_picture(self,array): # picture received from user is a byte array need to convert into image
picture = io.BytesIO(array)
image = Image.open(picture).convert("RGB")
self.curr_picture = image # store it temp
def final_(self,img):
self.final_img = img
def get_final(self):
return self.final_img
def get_picture(self):
return self.curr_picture
def change_model(self,model):
self.model = model
def get_model(self):
return self.model
def get_call(self):
return self.call
def call_engine(self,type):
model_id = self.model_id
call = self.get_call()
device = ("cuda" if torch.cuda.is_available() else "cpu")
if not call[type]:
if True in list(call.values()):
for k,v in call.items():
if v == True:
call[k] = False
if type == 1:
scheduler = DDIMScheduler.from_pretrained(model_id,subfolder = "scheduler")
pipe = StableDiffusionPipeline.from_pretrained(model_id,scheduler= scheduler, torch_dtype = torch.float16)
else:
pipe = StableDiffusionImg2ImgPipeline.from_pretrained(model_id,torch_dtype = torch.float16)
pipe = pipe.to(device)
self.model = pipe
call[type] = True
return self.get_model()
# Path: backend.py
def post_process(image,to_doc = True):
def resize_image(image, max_size):
quality = 95
while True:
with io.BytesIO() as file:
image.save(file, format='JPEG', quality=quality)
size = file.tell() / 1024 # Size in KB
if size <= max_size:
break
quality -= 5 # Decrease quality by 5. You can change it as needed.
if quality < 0:
raise Exception("Cannot reduce image size under the limit without losing too much quality.")
return image
def enforce_ratio(image,max_ratio): # stick to 20; 1
width, height = image.size
ratio = width / height
if ratio > max_ratio:
new_width = height * max_ratio
image = image.resize((int(new_width), height), Image.ANTIALIAS)
elif ratio < 1 / max_ratio:
new_height = width * max_ratio
image = image.resize((width, int(new_height)), Image.ANTIALIAS)
return image
def limit_pixels(image, max_pixels):
width, height = image.size
current_pixels = width * height
if current_pixels > max_pixels:
# Calculate the scale factor
scale_factor = (max_pixels / current_pixels) ** 0.5
new_width = int(width * scale_factor)
new_height = int(height * scale_factor)
image = image.resize((new_width, new_height), Image.ANTIALIAS)
return image
def pil_to_file(image):
file = io.BytesIO()
if to_doc:
image.save(file, format='PDF')
else:
image.save(file,format = 'JPG')
file.seek(0)
return file
if not to_doc:
image = resize_image(image, 9 * 1024)
image = enforce_ratio(image,18)
image = limit_pixels(image, 8000)
image = pil_to_file(image)
return image
# Path: bot.py
from telegram import ReplyKeyboardMarkup, ReplyKeyboardRemove, Update,InlineKeyboardButton,InlineKeyboardMarkup
from telegram.ext import (
Application,
CommandHandler,
ContextTypes,
ConversationHandler,
MessageHandler,
CallbackQueryHandler,
filters,
CallbackContext,
)
from backend import BackEnd,post_process
from PIL import Image
import numpy as np
import json
import logging
import yaml
import emoji
import asyncio
# Simple telegram bot that takes uses stable diffusion
''' Importing YAML'''
with open("config .yaml", "r") as f:
config = yaml.safe_load(f)
model = config['model']
api_key = config['API_KEY']
''' States for bot'''
ONE,TWO,DOCUMENT,PHOTO = range(4)
START,T2IMG,T2IMG2,IMG2IMG,IMG2IMG2,OUTPUT= range(6)
''' User logging'''
logging.basicConfig(
format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s', level = logging.INFO
)
logger = logging.getLogger(__name__)
''' Important pipeline for stable diffusion'''
| engine = BackEnd(model) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: khabbazan/Mattermost-Subscriptions
# Path: apps/chat/gql/types.py
class MessageQueryType(graphene.ObjectType):
"""
GraphQL type representing a message in a chat system.
"""
id = graphene.String(description="Unique identifier of the message.")
def resolve_id(root, info):
"""Resolve the message ID."""
return root["id"]
message = graphene.String(description="Content of the message.")
def resolve_message(root, info):
"""Resolve the message content, with special handling for system messages."""
if root["type"] == "system_join_team":
return "Welcome"
return root["message"]
create_at = graphene.String(description="Timestamp when the message was created.")
def resolve_create_at(root, info):
"""Resolve the creation timestamp of the message."""
return root["create_at"]
owner = graphene.Field(UserQueryType, description="User who sent the message.")
def resolve_owner(root, info):
"""Resolve the owner (sender) of the message."""
if isinstance(info.context, WSGIRequest) or isinstance(info.context, ASGIRequest):
return User.objects.filter(username=root["username"]).first()
else:
return User.objects.filter(username=root["username"]).afirst()
type = graphene.String(description="Type of the message, e.g., 'text', 'image', 'system_join_team'.")
def resolve_type(root, info):
"""Resolve the type of the message."""
return root["type"]
# Path: helpers/channels_graphql_ws/subscription.py
LOG = logging.getLogger(__name__)
class Subscription(graphene.ObjectType):
class SubscriptionOptions(graphene.types.objecttype.ObjectTypeOptions):
def broadcast(cls, *, group=None, payload=None):
async def broadcast_async(cls, *, group=None, payload=None):
def broadcast_sync(cls, *, group=None, payload=None):
def unsubscribe(cls, *, group=None):
async def unsubscribe_async(cls, *, group=None):
def unsubscribe_sync(cls, *, group=None):
def Field(cls, name=None, description=None, deprecation_reason=None, required=False): # noqa
def __init_subclass_with_meta__(
cls,
subscribe=None,
publish=None,
unsubscribed=None,
output=None,
arguments=None,
_meta=None,
**options,
): # pylint: disable=arguments-renamed
def _group_name(cls, group=None):
def _channel_layer(cls):
# Path: apps/chat/gql/subscriptions.py
import graphene
from apps.chat.gql.types import MessageQueryType
from helpers.channels_graphql_ws import subscription
class OnNewChatMessage(subscription.Subscription):
"""
GraphQL Subscription for new chat messages.
This subscription allows clients to listen for new messages on a specified channel.
"""
channel_identifier = graphene.String()
| message = graphene.Field(MessageQueryType) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Hatins/DEOE
# Path: models/detection/yolox/models/network_blocks.py
class BaseConv(nn.Module):
"""A Conv2d -> Batchnorm -> silu/leaky relu block"""
def __init__(
self, in_channels, out_channels, ksize, stride, groups=1, bias=False, act="silu"
):
super().__init__()
# same padding
pad = (ksize - 1) // 2
self.conv = nn.Conv2d(
in_channels,
out_channels,
kernel_size=ksize,
stride=stride,
padding=pad,
groups=groups,
bias=bias,
)
self.bn = nn.BatchNorm2d(out_channels)
self.act = get_activation(act, inplace=True)
def forward(self, x):
return self.act(self.bn(self.conv(x)))
def fuseforward(self, x):
return self.act(self.conv(x))
# Path: models/detection/yolox/models/network_blocks.py
class CSPLayer(nn.Module):
"""C3 in yolov5, CSP Bottleneck with 3 convolutions"""
def __init__(
self,
in_channels,
out_channels,
n=1,
shortcut=True,
expansion=0.5,
depthwise=False,
act="silu",
):
"""
Args:
in_channels (int): input channels.
out_channels (int): output channels.
n (int): number of Bottlenecks. Default value: 1.
"""
# ch_in, ch_out, number, shortcut, groups, expansion
super().__init__()
hidden_channels = int(out_channels * expansion) # hidden channels
self.conv1 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)
self.conv2 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)
self.conv3 = BaseConv(2 * hidden_channels, out_channels, 1, stride=1, act=act)
module_list = [
Bottleneck(
hidden_channels, hidden_channels, shortcut, 1.0, depthwise, act=act
)
for _ in range(n)
]
self.m = nn.Sequential(*module_list)
def forward(self, x):
x_1 = self.conv1(x)
x_2 = self.conv2(x)
x_1 = self.m(x_1)
x = torch.cat((x_1, x_2), dim=1)
return self.conv3(x)
# Path: models/detection/yolox/models/network_blocks.py
class DWConv(nn.Module):
"""Depthwise Conv + Conv"""
def __init__(self, in_channels, out_channels, ksize, stride=1, act="silu"):
super().__init__()
self.dconv = BaseConv(
in_channels,
in_channels,
ksize=ksize,
stride=stride,
groups=in_channels,
act=act,
)
self.pconv = BaseConv(
in_channels, out_channels, ksize=1, stride=1, groups=1, act=act
)
def forward(self, x):
x = self.dconv(x)
return self.pconv(x)
# Path: data/utils/types.py
class DataType(Enum):
class DatasetType(Enum):
class DatasetMode(Enum):
class DatasetSamplingMode(StrEnum):
class ObjDetOutput(Enum):
EV_REPR = auto()
FLOW = auto()
IMAGE = auto()
OBJLABELS = auto()
OBJLABELS_SEQ = auto()
IS_PADDED_MASK = auto()
IS_FIRST_SAMPLE = auto()
TOKEN_MASK = auto()
GEN1 = auto()
GEN4 = auto()
TRAIN = auto()
VALIDATION = auto()
TESTING = auto()
RANDOM = 'random'
STREAM = 'stream'
MIXED = 'mixed'
LABELS_PROPH = auto()
PRED_PROPH = auto()
EV_REPR = auto()
SKIP_VIZ = auto()
# Path: models/detection/yolox_extension/models/yolo_pafpn.py
from typing import Dict, Optional, Tuple
from torch import compile as th_compile
from ...yolox.models.network_blocks import BaseConv, CSPLayer, DWConv
from data.utils.types import BackboneFeatures
import torch as th
import torch.nn as nn
"""
Original Yolox PAFPN code with slight modifications
"""
try:
except ImportError:
th_compile = None
class YOLOPAFPN(nn.Module):
"""
Removed the direct dependency on the backbone.
"""
def __init__(
self,
depth: float = 1.0,
in_stages: Tuple[int, ...] = (2, 3, 4),
in_channels: Tuple[int, ...] = (256, 512, 1024),
depthwise: bool = False,
act: str = "silu",
compile_cfg: Optional[Dict] = None,
):
super().__init__()
assert len(in_stages) == len(in_channels)
assert len(in_channels) == 3, 'Current implementation only for 3 feature maps'
self.in_features = in_stages
self.in_channels = in_channels
Conv = DWConv if depthwise else BaseConv
###### Compile if requested ######
if compile_cfg is not None:
compile_mdl = compile_cfg['enable']
if compile_mdl and th_compile is not None:
self.forward = th_compile(self.forward, **compile_cfg['args'])
elif compile_mdl:
print('Could not compile PAFPN because torch.compile is not available')
##################################
self.upsample = lambda x: nn.functional.interpolate(x, scale_factor=2, mode='nearest-exact')
self.lateral_conv0 = BaseConv(
in_channels[2], in_channels[1], 1, 1, act=act
)
| self.C3_p4 = CSPLayer( |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: yeyingdege/ctr-din-pytorch
# Path: din/embedding.py
class EmbeddingLayer(nn.Module):
def __init__(self, num_emb, embedding_dim):
super(EmbeddingLayer, self).__init__()
self.embeddings = nn.Embedding(num_emb, embedding_dim)
nn.init.xavier_uniform_(self.embeddings.weight)
def forward(self, batch_cat):
batch_embedding = self.embeddings(batch_cat)
return batch_embedding
# Path: din/fc.py
class FCLayer(nn.Module):
def __init__(self, input_size,
hidden_size,
bias,
batch_norm=False,
dropout_rate=0.,
activation='relu',
use_sigmoid=False,
dice_dim=2):
super(FCLayer, self).__init__()
self.use_sigmoid = use_sigmoid
layers = []
if batch_norm:
layers.append(nn.BatchNorm1d(input_size))
# FC -> activation -> dropout
layers.append(nn.Linear(input_size, hidden_size, bias=bias))
if activation.lower() == 'relu':
layers.append(nn.ReLU(inplace=True))
elif activation.lower() == 'dice':
assert dice_dim
layers.append(Dice(hidden_size, dim=dice_dim))
elif activation.lower() == 'prelu':
layers.append(nn.PReLU())
else: # None
pass
layers.append(nn.Dropout(p=dropout_rate))
self.fc = nn.Sequential(*layers)
if self.use_sigmoid:
self.output_layer = nn.Sigmoid()
# weight initialization xavier_normal (or glorot_normal in keras, tf)
for m in self.modules():
if isinstance(m, nn.Linear):
nn.init.xavier_normal_(m.weight, gain=1.0)
if m.bias is not None:
nn.init.zeros_(m.bias)
pass
def forward(self, x):
return self.output_layer(self.fc(x)) if self.use_sigmoid else self.fc(x)
# Path: din/attention.py
class DinAttentionLayer(nn.Module):
def __init__(self, embedding_dim=36):
super(DinAttentionLayer, self).__init__()
self.local_att = LocalActivationUnit(hidden_size=[80, 40, 1],
bias=[True, True, True],
embedding_dim=embedding_dim,
batch_norm=False)
def forward(self, query_ad, user_behavior, user_behavior_length):
# query ad : batch_size * embedding_size
# user behavior : batch_size * time_seq_len * embedding_size
# user behavior length: batch_size * time_seq_len
# output : batch_size * 1 * embedding_size
attention_score = self.local_att(query_ad, user_behavior) # [128, 100, 1]
attention_score = torch.transpose(attention_score, 1, 2) # B * 1 * T
# define mask by length
user_behavior_length = user_behavior_length.type(torch.LongTensor)
mask = torch.arange(user_behavior.size(1))[None, :] < user_behavior_length[:, None]
# mask
score = torch.mul(attention_score, mask.type(torch.cuda.FloatTensor)) # batch_size *
score = F.softmax(score, dim=-1)
# multiply weight
output = torch.matmul(score, user_behavior)
return output
# Path: din/model.py
import torch
import torch.nn as nn
from torch.nn import functional as F
from .embedding import EmbeddingLayer
from .fc import FCLayer
from .attention import DinAttentionLayer
class DeepInterestNetwork(nn.Module):
def __init__(self, n_uid, n_mid, n_cat, EMBEDDING_DIM, HIDDEN_DIM=[162,200,80,2]):
super(DeepInterestNetwork, self).__init__()
self.embedding_dim = EMBEDDING_DIM
self.hid_dim = HIDDEN_DIM
# embeddings
self.uid_embeddings = EmbeddingLayer(n_uid, self.embedding_dim)
self.mid_embeddings = EmbeddingLayer(n_mid, self.embedding_dim)
self.cat_embeddings = EmbeddingLayer(n_cat, self.embedding_dim)
self.attn = DinAttentionLayer(embedding_dim=self.embedding_dim*2)
mlp_input_dim = self.embedding_dim * 9
self.mlp = nn.Sequential(
| FCLayer(mlp_input_dim, hidden_size=self.hid_dim[1], bias=True, batch_norm=True, activation='dice'), |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: iamlooper/VIC-TG-Bot
# Path: app/config.py
class _Config:
class CMD:
def __init__(self, func, path, doc):
def __init__(self):
def __str__(self):
# Path: app/core/client/conversation.py
class Conversation:
CONVO_DICT: dict[int, "Conversation"] = {}
class DuplicateConvo(Exception):
def __init__(self, chat: str | int):
super().__init__(f"Conversation already started with {chat} ")
def __init__(
self, chat_id: int | str, filters: Filter | None = None, timeout: int = 10
):
self.chat_id = chat_id
self.filters = filters
self.timeout = timeout
self.responses: list = []
self.set_future()
from app import bot
self._client = bot
def __str__(self):
return json.dumps(self.__dict__, indent=4, ensure_ascii=False, default=str)
def set_future(self, *args, **kwargs):
future = asyncio.Future()
future.add_done_callback(self.set_future)
self.response = future
async def get_response(self, timeout: int | None = None) -> Message | None:
try:
resp_future: asyncio.Future = await asyncio.wait_for(
self.response, timeout=timeout or self.timeout
)
return resp_future
except asyncio.TimeoutError:
raise TimeoutError("Conversation Timeout")
async def send_message(
self,
text: str,
timeout=0,
get_response=False,
**kwargs,
) -> Message | tuple[Message, Message]:
message = await self._client.send_message(
chat_id=self.chat_id, text=text, **kwargs
)
if get_response:
response = await self.get_response(timeout=timeout or self.timeout)
return message, response
return message
async def send_document(
self,
document,
caption="",
timeout=0,
get_response=False,
**kwargs,
) -> Message | tuple[Message, Message]:
message = await self._client.send_document(
chat_id=self.chat_id,
document=document,
caption=caption,
force_document=True,
**kwargs,
)
if get_response:
response = await self.get_response(timeout=timeout or self.timeout)
return message, response
return message
async def __aenter__(self) -> "Conversation":
if isinstance(self.chat_id, str):
self.chat_id = (await self._client.get_chat(self.chat_id)).id
if (
self.chat_id in Conversation.CONVO_DICT.keys()
and Conversation.CONVO_DICT[self.chat_id].filters == self.filters
):
raise self.DuplicateConvo(self.chat_id)
Conversation.CONVO_DICT[self.chat_id] = self
return self
async def __aexit__(self, exc_type, exc_val, exc_tb):
Conversation.CONVO_DICT.pop(self.chat_id, None)
if not self.response.done():
self.response.cancel()
# Path: app/core/client/filters.py
from pyrogram import filters as _filters
from pyrogram.types import Message
from app import Config
from app.core.client.conversation import Conversation
# Overall BOT filters
convo_filter = _filters.create(
lambda _, __, message: (message.chat.id in Conversation.CONVO_DICT.keys())
and (not message.reactions)
)
def cmd_check(message: Message, trigger: str) -> bool:
start_str = message.text.split(maxsplit=1)[0]
cmd = start_str.replace(trigger, "", 1)
| return bool(cmd in Config.CMD_DICT.keys()) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Enthusiasm23/primkit
# Path: src/primkit/config.py
LOG_LEVEL = os.environ.get('LOG_LEVEL', 'INFO') # 日志级别
# Path: src/primkit/config.py
LOG_FILE = os.environ.get('LOG_FILE', None) # 日志文件路径
# Path: src/primkit/config.py
LOG_FORMAT = os.environ.get('LOG_FORMAT', '%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 日志格式
# Path: src/primkit/config.py
LOG_FILE_MODE = os.environ.get('LOG_FILE_MODE', 'a') # 日志文件模式
# Path: src/primkit/config.py
MAX_LOG_SIZE = int(os.environ.get('MAX_LOG_SIZE', 10485760)) # 最大日志文件大小（10MB）
# Path: src/primkit/config.py
BACKUP_COUNT = int(os.environ.get('BACKUP_COUNT', 3)) # 保留的日志文件数量
# Path: src/primkit/config.py
LOG_STREAM = os.environ.get('LOG_STREAM', 'True').lower() in ('true', '1', 't') # 是否输出日志到控制台
# Path: src/primkit/utils/LoggerSetup.py
import logging
import logging.handlers
from ..config import LOG_LEVEL, LOG_FILE, LOG_FORMAT, \
LOG_FILE_MODE, MAX_LOG_SIZE, BACKUP_COUNT, LOG_STREAM
def setup_logging(
level=None,
log_file=None,
format=None,
log_file_mode=None,
max_log_size=None,
backup_count=None,
stream=None
):
"""
Configure logging for the application.
:param level: The logging level, e.g., 'DEBUG', 'INFO', 'WARNING'. Defaults to value from config.py but can be overridden by user input.
:param log_file: Path to the log file. If specified, logs will be written to the file. Defaults to value from config.py but can be overridden by user input.
:param format: The format for the logging messages. Defaults to value from config.py but can be overridden by user input.
:param log_file_mode: The mode for writing to the log file, e.g., 'a' for append mode. Defaults to value from config.py but can be overridden by user input.
:param max_log_size: The maximum size of the log file in bytes. When exceeded, the log will rotate. Defaults to value from config.py but can be overridden by user input.
:param backup_count: The number of backup log files to keep. Defaults to value from config.py but can be overridden by user input.
:param stream: Whether to output logs to the console. Defaults to value from config.py but can be overridden by user input.
The function uses the default configuration or configuration provided by the user. Logging can be directed to a file, console, or both based on parameters.
"""
# Use the default configuration or user-provided configuration
if level is not None:
if isinstance(level, int):
log_level = level
else:
log_level = getattr(logging, level.upper(), logging.INFO)
else:
if isinstance(LOG_LEVEL, int):
log_level = LOG_LEVEL
else:
log_level = getattr(logging, LOG_LEVEL.upper(), logging.INFO)
log_file = log_file if log_file is not None else LOG_FILE
format = format if format is not None else LOG_FORMAT
| log_file_mode = log_file_mode if log_file_mode is not None else LOG_FILE_MODE |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Wangyuhao06/2022-adhoc
# Path: pymobility/models/mobility.py
def random_waypoint(*args, **kwargs):
return iter(RandomWaypoint(*args, **kwargs))
# Path: src/node.py
class Node(object):
def __init__(self,id_node):
super(Node, self).__init__()
#multi-agent sys setting
self.node_max=36
self.act_range=self.node_max-1 #最大邻居范围
# current agent-property setting
self.id=id_node#该节点id
# 1 - packets
self.packets_ToSend_id=[]#该节点当前待传的包
self.packets_id_list=[]#该节点至今为止保存过的包id
self.sending_flag=0
self.rec_flag=0
self.trans_task_send=Queue(maxsize=1)#该节点当前传输的任务
self.trans_taskID_rec=[]#该节点当前接收的任务
# 2 - energy
self.current_amp_send=0#节点当前发送增益--------动作
#self.current_amp_receive=0#节点当前接收增益--------动作
self.current_power_send=0#节点当前发送功率
self.current_power_receive=0#节点当前接收功率
self.power_list=[]#节点使用能量记录
self.energy_consumption=0#截至现在能量消耗
# 3 - freq
self.current_freqB=[1]#当前选用频谱块--------动作
self.freqB_list=[1]#频谱块历史
# 4 - topology
self.neibor_idlist=[]
self.next_hop_id=-1#下一条节点id--------动作
# 5 - observation
#self.ob_send=[]
# def observation_rec(self,send_node):
# if len(self.ob_send)==0 or len(send_node.ob_send)==0 :
# raise ValueError("send observation unfinished")
# self.ob_rec.append(self.ob_send[-1])
# self.ob_rec.append(send_node.ob_send[-1])
# return self.ob_rec
def get_send_action(self,ob,action_space):
###缺省决策###
#改变属性
return self.current_amp_send,self.current_freqB,self.next_hop_id
def get_rec_action(self,ob):
###缺省决策###
#改变属性
return self.current_amp_receive
# Path: src/packet.py
class Packet(object):
def __init__(self,id_packet,packet_size,ori_node_id,dst_node_id,time_start_0):
super(Packet, self).__init__()
self.id=id_packet
self.size=packet_size
#节点属性
self.ori_node_id=ori_node_id
self.cur_node_id=ori_node_id
self.dst_node_id=dst_node_id
self.node_list=[ori_node_id]
#T-T属性
self.cur_trans_task_id=-100
self.in_TR=0
self.trans_task_IDlist=[]
#路由属性
self.time_start=time_start_0
self.time_use=0
self.arrive_flag=0
def packet_trans_update(self,trans_task):
if trans_task.trans_property[2]!=self.id:
raise ValueError('trans_task not matched')
self.cur_trans_task_id=trans_task.id
# Path: src/transtask.py
class Trans_task(object):
def __init__(self,trans_id,node_send,node_rec,packet):
self.id=trans_id
self.trans_property=(node_send.id,node_rec.id,packet.id)#基本属性
self.packsize=packet.size
####frequency block info####
self.FreqB_occup=node_send.current_freqB #占用频谱块id
####SINR and Capacity####
self.SNR_C=([],1)#Y(SNR,Capacity)-----------------[X(timeslot1:SNR,Capacity),(timeslot2:SNR,Capacity),...]
####time of trans####
self.time_use=1#int(self.packsize/self.SNR_C[1])+1
self.time_cnt=0
self.finish_flag=0
####energy setting####
self.energy_property = (node_send.current_amp_send,RECAMP)
self.energy_consume=(node_send.current_amp_send*packet.size*PACKENERGY,RECAMP*packet.size*PACKENERGY)
self.power_consume=(round(node_send.current_amp_send*packet.size*PACKENERGY/self.time_use,6),round(RECAMP*packet.size*PACKENERGY/self.time_use,6))
def show_info(self):
return self.trans_property[0],self.trans_property[1],self.trans_property[2]
def Trans_task_update(self):
if self.finish_flag:
return 1
if self.time_cnt>=self.time_use:
self.finish_flag=1
return 1
elif self.time_cnt<self.time_use:
self.time_cnt+=1
return 0
#trans_task=tuple([],{},(node_send_id,node_send_amp,node_rec_id,node_rec_amp,packet_id),0)
#tuple:([占用频谱块id]，{(timeslot1:SNR,Capacity),(timeslot2:SNR,Capacity),...},(基本属性:发送节点id,发送增益,接收节点id,接收增益,包id),完成标志位)
# Path: src/env.py
import random
import numpy as np
from math import log2, log10
from queue import Queue
from pymobility.models.mobility import random_waypoint
from src.node import Node
from src.packet import Packet
from src.parameter import *
from src.transtask import Trans_task
class Environment():
#初始化环境
def __init__(self):
#初始数据-最大节点数
self.node_max=NODE_MAX
self.node_space_size=NODE_MAX
self.node_moving_area=MOV_AREA
#初始化二维平面
| self.geo_area = random_waypoint(self.node_max, dimensions=(MOV_AREA, MOV_AREA), velocity=(10, 15), wt_max=1.0) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: karthicksivakumarp/gui_read_csv
# Path: read_from_csv/read_csv_file.py
class read_csv_data:
def __init__(self):
def read_mult_csv_file(self):
# Path: data_analysis/analyze_data.py
class analyze_csv_data:
def __init__(self):
def pass_data_frame(self, df_list, csv_filepaths, columns):
def analyze_data_all(self):
def analyze_data_single_csv(self, index):
# Path: report_generation/generate_report.py
class generate_report:
def __init__(self):
"""
Constructor for the generate_report class.
Initializes instance variables to store analysis data.
Customize this file for your needs to generate report
"""
# Initialize instance variables to store analysis data
self.analysis_data_1 = None
self.analysis_data_2 = None
self.analysis_data_3 = None
def generate_report(self, data1, data2, data3):
"""
Method to generate a report by assigning analysis data to instance variables.
Parameters:
- data1: The first set of analysis data.
- data2: The second set of analysis data.
- data3: The third set of analysis data.
"""
# Assign data1 to analysis_data_1
self.analysis_data_1 = data1
# Assign data2 to analysis_data_2
self.analysis_data_2 = data2
# Assign data3 to analysis_data_3
self.analysis_data_3 = data3
# Print analysis_data_1
print("Analysis Data 1:")
print(self.analysis_data_1)
# Print analysis_data_2
print("Analysis Data 2:")
print(self.analysis_data_2)
# Print analysis_data_3
print("Analysis Data 3:")
print(self.analysis_data_3)
# Path: user_interface/gui.py
class UI(Frame):
def __init__(self, root, ui_read_csv, ui_data_analysis, ui_report_gen):
def set_status_message(self, message):
def init_menu_bar(self):
def config_frame(self):
def top_left_frame(self):
def bottom_left_frame(self):
def right_frame(self):
def read_csv_files(self):
def on_listbox_select(self, event):
def analyze_csv_files(self):
def analyze_all_csv_files(self):
def generate_report_single(self):
def generate_report_all(self):
# Path: main.py
from read_from_csv import read_csv_file
from data_analysis import analyze_data
from report_generation import generate_report
from tkinter import Tk
from user_interface import gui
# Import necessary modules
# Initialize CSV reader instance
read_csv = read_csv_file.read_csv_data()
# Obtain the function/method for reading multiple CSV files
# Note: "read_mult_csv_file" is a function or method defined in the "read_csv_file" module
main_read_csv = read_csv.read_mult_csv_file
# Initialize data analyzer instance
analyze_data = analyze_data.analyze_csv_data()
# Initialize report generator instance
report_gen = generate_report.generate_report()
# Create the main Tkinter window
root = Tk()
root.title('Csv DataAnalyzer') # Set the title of the Tkinter window
root.geometry("800x600") # Set the initial dimensions of the Tkinter window
# Create the user interface (GUI) using the UI class from the "user_interface" module
# Pass the necessary components (main_read_csv, analyze_data, report_gen) to the GUI
| gui.UI(root, main_read_csv, analyze_data, report_gen)
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Slenderman00/Ask-Surf
# Path: AskSurf/settings.py
def load_settings():
# check if settings.toml exists
if not settings_exist():
create_settings()
edit_settings()
return load_settings()
with open(own_dir / "settings.toml", "r") as f:
settings = toml.load(f)
return settings
# Path: AskSurf/settings.py
def settings_exist():
return (own_dir / "settings.toml").exists()
# Path: AskSurf/settings.py
def edit_settings():
os.system(f"{select_editor()} {own_dir / 'settings.toml'}")
# Path: AskSurf/cli.py
import os
import requests
import argparse
import tqdm
import time
import subprocess
import sys
from pathlib import Path
from halo import Halo
from .settings import load_settings, settings_exist, edit_settings
settings = {}
own_dir = Path(__file__).parent.absolute()
question_pipe = own_dir / "question_pipe"
response_pipe = own_dir / "response_pipe"
def conditional_decorator(dec, condition):
def decorator(func):
if not condition:
# Return the function unchanged, not decorated.
return func
return dec(func)
return decorator
def parse_message(message):
# replace the tags with the correct color codes
message = message.replace("[RED]", "\033[31m")
message = message.replace("[YELLOW]", "\033[33m")
message = message.replace("[ORANGE]", "\033[33m")
message = message.replace("[GREEN]", "\033[32m")
message = message.replace("[PURPLE]", "\033[35m")
message = message.replace("[BLUE]", "\033[34m")
message = message.replace("[NORMAL]", "\033[0m")
# replace all end tags with the normal color code
message = message.replace("[/RED]", "\033[0m")
message = message.replace("[/YELLOW]", "\033[0m")
message = message.replace("[/ORANGE]", "\033[0m")
message = message.replace("[/GREEN]", "\033[0m")
message = message.replace("[/PURPLE]", "\033[0m")
message = message.replace("[/BLUE]", "\033[0m")
message = message.replace("[/NORMAL]", "\033[0m")
return message
def init():
if not model_exists():
print("Please select a model")
download_model(select_model())
if not settings_exist():
print("Please make sure the settings are correct")
settings = load_settings()
exit(1)
def main():
"""Main entry point for the application"""
init()
# parse the arguments
parser = argparse.ArgumentParser(description="AskSurf CLI")
parser.add_argument(
"question",
nargs=argparse.REMAINDER,
help="The question to ask Dolphin",
)
parser.add_argument(
"--model",
"-m",
action="store_true",
help="The model to use",
)
parser.add_argument(
"--delete",
"-d",
action="store_true",
help="Delete the model",
)
parser.add_argument(
"--kill",
"-k",
action="store_true",
help="Kill the Dolphin service",
)
parser.add_argument(
"--settings",
"-s",
action="store_true",
help="Edit the settings",
)
args = parser.parse_args()
if args.model:
download_model(select_model())
return
if args.delete:
delete_model()
return
if args.kill:
os.system("pkill -f dolphin_service.py")
return
if args.settings:
| edit_settings() |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: davidsvy/fractal_video
# Path: src/utils/data.py
def dataset_stats(root, ext):
n_train = len(find_files(dir=os.path.join(root, 'train'), ext=ext))
n_val = len(find_files(dir=os.path.join(root, 'val'), ext=ext))
n_test = len(find_files(dir=os.path.join(root, 'test'), ext=ext))
print(f'train -> {n_train} files')
print(f'val -> {n_val} files')
print(f'test -> {n_test} files')
# Path: src/utils/other.py
def run_bash(command):
return subprocess.run(command, shell=True, capture_output=True, text=True)
# Path: src/prepare_data/diving48.py
import json
import os
import shutil
from ..utils.data import dataset_stats
from ..utils.other import run_bash
def move_files(path_split, dir_src, dir_tgt, ext):
with open(path_split, 'r') as file:
lut = json.load(file)
for item in lut:
filename = f'{item["vid_name"]}.{ext}'
path_src = os.path.join(dir_src, filename)
label = str(item['label'])
dir_label = os.path.join(dir_tgt, label)
path_tgt = os.path.join(dir_label, filename)
os.makedirs(dir_label, exist_ok=True)
shutil.move(path_src, path_tgt)
def diving48(root):
"""
train -> 15943 files
val -> 2096 files
"""
url_data = 'http://www.svcl.ucsd.edu/projects/resound/Diving48_rgb.tar.gz'
url_split_train = 'http://www.svcl.ucsd.edu/projects/resound/Diving48_train.json'
url_split_val = 'http://www.svcl.ucsd.edu/projects/resound/Diving48_test.json'
path_data = os.path.join(root, os.path.basename(url_data))
path_split_train = os.path.join(root, os.path.basename(url_split_train))
path_split_val = os.path.join(root, os.path.basename(url_split_val))
dir_src = os.path.join(root, 'rgb')
dir_train = os.path.join(root, 'train')
dir_val = os.path.join(root, 'val')
ext = 'mp4'
os.makedirs(dir_train, exist_ok=True)
os.makedirs(dir_val, exist_ok=True)
print('\nDownloading DIVING48...')
run_bash(f'wget {url_split_train} -P {root}')
run_bash(f'wget {url_split_val} -P {root}')
run_bash(f'wget {url_data} -P {root}')
print('Extracting DIVING48...')
run_bash(f'tar -xf {path_data} -C {root}')
os.remove(path_data)
move_files(
path_split=path_split_train, dir_src=dir_src,
dir_tgt=dir_train, ext=ext
)
move_files(
path_split=path_split_val, dir_src=dir_src,
dir_tgt=dir_val, ext=ext
)
shutil.rmtree(dir_src)
os.remove(path_split_train)
os.remove(path_split_val)
| dataset_stats(root=root, ext=ext) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: OpenBrickProtocolFoundation/client
# Path: tetrion.py
class Event(NamedTuple):
key: Key
type: EventType
frame: int
# Path: tetrion.py
class EventType(Enum):
PRESSED = 0
RELEASED = 1
# Path: tetrion.py
class Key(Enum):
LEFT = 0
RIGHT = 1
DROP = 2
# Path: tetrion.py
class Tetrion:
def __init__(self) -> None:
self._tetrion = _create_tetrion()
def try_get_active_tetromino(self) -> Optional[Tetromino]:
return _tetrion_try_get_active_tetromino(self._tetrion)
def simulate_up_until(self, frame: int) -> None:
_tetrion_simulate_up_until(self._tetrion, frame)
def enqueue_event(self, event: Event) -> None:
_tetrion_enqueue_event(self._tetrion, event)
def matrix(self) -> Matrix:
matrix = _tetrion_matrix(self._tetrion)
minos: list[TetrominoType] = []
for y in range(self.height):
for x in range(self.width):
minos.append(_matrix_get(matrix, Vec2(x, y)))
return Matrix(minos, self.width)
@cached_property
def width(self) -> int:
return _tetrion_width()
@cached_property
def height(self) -> int:
return _tetrion_height()
def __enter__(self) -> Self:
return self
def __exit__(self, exc_type: type[BaseException], exc_val: BaseException, exc_tb: types.TracebackType) -> bool:
self.__del__()
return exc_type is None
def __del__(self) -> None:
if self._tetrion is not None:
_destroy_tetrion(self._tetrion)
self._tetrion = None
# Path: main.py
import pygame
from tetrion import Event
from tetrion import EventType
from tetrion import Key
from tetrion import Tetrion
def main() -> None:
frame = 0
with Tetrion() as tetrion:
pygame.init()
RECT_SIZE = 30
size = (RECT_SIZE * tetrion.width, (RECT_SIZE + 2) * tetrion.height)
screen = pygame.display.set_mode(size)
COLORS = [(0, 0, 0),
(0, 240, 240),
(0, 0, 240),
(240, 160, 0),
(240, 240, 0),
(0, 240, 0),
(160, 0, 240),
(240, 0, 0)]
done = False
clock = pygame.time.Clock()
while not done:
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
done = True
elif event.key == pygame.K_a:
| tetrion.enqueue_event(Event(key=Key.LEFT, type=EventType.PRESSED, frame=frame)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: Birch-san/natten-fwd-ad
# Path: src/natten_block.py
class NattenBlock(Module):
def __init__(self, d_model: int, d_head: int, kernel_size: int):
super().__init__()
self.d_head = d_head
self.n_heads = d_model // d_head
self.kernel_size = kernel_size
self.qkv_proj = Linear(d_model, d_model * 3, bias=False)
self.out_proj = Linear(d_model, d_model, bias=False)
def forward(self, x: FloatTensor) -> FloatTensor:
qkv = self.qkv_proj(x)
q, k, v = rearrange(qkv, "n h w (t nh e) -> t n nh h w e", t=3, e=self.d_head)
q = q / self.d_head**.5
qk = natten2dqk(q, k, self.kernel_size, 1)
a = qk.softmax(dim=-1)
x = natten2dav(a, v, self.kernel_size, 1)
x = rearrange(x, "n nh h w e -> n h w (nh e)")
x = self.out_proj(x)
return x
# Path: src/hood_attn_block.py
class NeighbourhoodAttnBlock(Module):
def __init__(self, d_model: int, d_head: int, kernel_size: int):
"""
Pure-PyTorch implementation of neighbourhood attention.
Uses global self-attention and a (very) complicated mask.
Consequently it (probably) supports:
- Mac
- PyTorch Forward-Mode Autodiff
- Nested tensors
"""
super().__init__()
self.d_head = d_head
self.n_heads = d_model // d_head
self.kernel_size = kernel_size
self.qkv_proj = Linear(d_model, d_model * 3, bias=False)
self.out_proj = Linear(d_model, d_model, bias=False)
def forward(self, x: FloatTensor) -> FloatTensor:
_, h, w, _ = x.shape
qkv = self.qkv_proj(x)
q, k, v = rearrange(qkv, "n h w (t nh e) -> t n nh (h w) e", t=3, e=self.d_head)
kernel_size=Dimensions(self.kernel_size, self.kernel_size)
canvas_size=Dimensions(h, w)
mask: BoolTensor = make_neighbourhood_mask(kernel_size, canvas_size, flatten_to_1d=True, device=x.device)
mask = mask.unsqueeze(0).unsqueeze(0)
x = scaled_dot_product_attention(q, k, v, attn_mask=mask)
x = rearrange(x, "n nh (h w) e -> n h w (nh e)", h=h, w=w, e=self.d_head)
x = self.out_proj(x)
return x
# Path: script/demo.py
import torch
import torch.autograd.forward_ad as fwAD
from torch import inference_mode, enable_grad
from torch.backends.cuda import sdp_kernel
from src.natten_block import NattenBlock
from src.hood_attn_block import NeighbourhoodAttnBlock
device=torch.device('cuda')
dtype=torch.bfloat16
seed=42
d_model=128
d_head=64
kernel_size=13
torch.manual_seed(seed)
| natten_block = NattenBlock(d_model, d_head=d_head, kernel_size=kernel_size).to(device=device, dtype=dtype) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ysyBrenda/Transformer-For-Geochemical-Anomaly-Detection
# Path: transformer/Models.py
class Transformer(nn.Module):
''' A sequence to sequence model with attention mechanism. '''
def __init__(
self, src_pad_idx, trg_pad_idx,
d_word_vec=38, d_model=38, d_inner=2048,
n_layers=6, n_head=8, d_k=38, d_v=38, dropout=0.1, n_position=2000,
):
super().__init__()
self.src_pad_idx, self.trg_pad_idx = src_pad_idx, trg_pad_idx
self.scale_prj = False #True
self.d_model = d_model
self.encoder = Encoder(
n_position=n_position,
d_word_vec=d_word_vec, d_model=d_model, d_inner=d_inner,
n_layers=n_layers, n_head=n_head, d_k=d_k, d_v=d_v,
pad_idx=src_pad_idx, dropout=dropout)
self.decoder = Decoder(
n_position=n_position,
d_word_vec=d_word_vec, d_model=d_model, d_inner=d_inner,
n_layers=n_layers, n_head=n_head, d_k=d_k, d_v=d_v,
pad_idx=trg_pad_idx, dropout=dropout)
for p in self.parameters():
if p.dim() > 1:
nn.init.xavier_uniform_(p)
assert d_model == d_word_vec, \
'To facilitate the residual connections, \
the dimensions of all module outputs shall be the same.'
def forward(self, src_seq, trg_seq):
src_mask=get_pad_mask(src_seq[:,:,0], self.src_pad_idx)
trg_mask=trg_seq[:, :,0] #.unsqueeze(1)
trg_mask = get_pad_mask(trg_mask, self.trg_pad_idx) & get_subsequent_mask(trg_mask)
enc_output,enc_slf_attn_list = self.encoder(src_seq, src_mask,return_attns=True)
dec_output, dec_slf_attn_list, dec_enc_attn_list= self.decoder(trg_seq, trg_mask, enc_output, src_mask,return_attns=True)
seq_logit=dec_output
return seq_logit.view(-1, seq_logit.size(2)),enc_slf_attn_list,dec_enc_attn_list
# Path: transformer/Translator.py
class Translator(nn.Module):
''' Load a trained model and translate in beam search fashion. '''
def __init__(
self, model,src_pad_idx):
super(Translator, self).__init__()
self.src_pad_idx = src_pad_idx
self.model = model
self.model.eval()
def _model_decode(self, trg_seq, enc_output, src_mask):
trg_mask = get_subsequent_mask(trg_seq[:, :,0] )
dec_output, dec_slf_attn,dec_enc_attn = self.model.decoder(trg_seq, trg_mask, enc_output, src_mask,return_attns=True)
seq_logit=dec_output
return seq_logit.view(-1, seq_logit.size(2)),dec_enc_attn
def translate_sentence(self, src_seq,trg_seq):
src_pad_idx= self.src_pad_idx
with torch.no_grad():
if len(src_seq.size())==2:
src_seq=src_seq.unsqueeze(0)
trg_seq=trg_seq.unsqueeze(0)
src_mask = get_pad_mask(src_seq[:,:,0], src_pad_idx)
enc_output, *_ = self.model.encoder(src_seq, src_mask)
dec_output,dec_enc_attn = self._model_decode(trg_seq.unsqueeze(0), enc_output, src_mask)
return dec_output,dec_enc_attn
# Path: anomaly_detection.py
import torch
import argparse
import dill as pickle
import numpy as np
import calculate_anomalyscore
import torch.utils.data as Data
import time
from tqdm import tqdm
from transformer.Models import Transformer
from transformer.Translator import Translator
'''
geochemical anomaly detection
1，reconstruct geochemical data with trained model.
2，then, identify geochemical anomaly
Author: ysyBrenda
'''
def load_model(opt, device):
checkpoint = torch.load(opt.model, map_location=device)
model_opt = checkpoint['settings']
| model = Transformer( |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: camenduru/MotionCtrl-hf
# Path: lvdm/basics.py
def conv_nd(dims, *args, **kwargs):
"""
Create a 1D, 2D, or 3D convolution module.
"""
if dims == 1:
return nn.Conv1d(*args, **kwargs)
elif dims == 2:
return nn.Conv2d(*args, **kwargs)
elif dims == 3:
return nn.Conv3d(*args, **kwargs)
raise ValueError(f"unsupported dimensions: {dims}")
# Path: lvdm/basics.py
def normalization(channels, num_groups=32):
"""
Make a standard normalization layer.
:param channels: number of input channels.
:return: an nn.Module for normalization.
"""
return GroupNormSpecific(num_groups, channels)
# Path: lvdm/basics.py
def zero_module(module):
"""
Zero out the parameters of a module and return it.
"""
for p in module.parameters():
p.detach().zero_()
return module
# Path: lvdm/common.py
def checkpoint(func, inputs, params, flag):
"""
Evaluate a function without caching intermediate activations, allowing for
reduced memory at the expense of extra compute in the backward pass.
:param func: the function to evaluate.
:param inputs: the argument sequence to pass to `func`.
:param params: a sequence of parameters `func` depends on but does not
explicitly take as arguments.
:param flag: if False, disable gradient checkpointing.
"""
if flag:
try:
return ckpt(func, *inputs)
except:
args = tuple(inputs) + tuple(params)
return CheckpointFunction.apply(func, len(inputs), *args)
else:
return func(*inputs)
# Path: lvdm/common.py
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d
# Path: lvdm/common.py
def exists(val):
return val is not None
# Path: lvdm/common.py
def init_(tensor):
dim = tensor.shape[-1]
std = 1 / math.sqrt(dim)
tensor.uniform_(-std, std)
return tensor
# Path: lvdm/common.py
def max_neg_value(t):
return -torch.finfo(t.dtype).max
# Path: lvdm/common.py
def uniq(arr):
return{el: True for el in arr}.keys()
# Path: lvdm/modules/attention.py
import math
import torch
import torch.nn.functional as F
import xformers
import xformers.ops
from functools import partial
from inspect import isfunction
from einops import rearrange, repeat
from torch import einsum, nn
from lvdm.basics import conv_nd, normalization, zero_module
from lvdm.common import checkpoint, default, exists, init_, max_neg_value, uniq
try:
XFORMERS_IS_AVAILBLE = True
except:
XFORMERS_IS_AVAILBLE = False
class RelativePosition(nn.Module):
""" https://github.com/evelinehong/Transformer_Relative_Position_PyTorch/blob/master/relative_position.py """
def __init__(self, num_units, max_relative_position):
super().__init__()
self.num_units = num_units
self.max_relative_position = max_relative_position
self.embeddings_table = nn.Parameter(torch.Tensor(max_relative_position * 2 + 1, num_units))
nn.init.xavier_uniform_(self.embeddings_table)
def forward(self, length_q, length_k):
device = self.embeddings_table.device
range_vec_q = torch.arange(length_q, device=device)
range_vec_k = torch.arange(length_k, device=device)
distance_mat = range_vec_k[None, :] - range_vec_q[:, None]
distance_mat_clipped = torch.clamp(distance_mat, -self.max_relative_position, self.max_relative_position)
final_mat = distance_mat_clipped + self.max_relative_position
# final_mat = th.LongTensor(final_mat).to(self.embeddings_table.device)
# final_mat = th.tensor(final_mat, device=self.embeddings_table.device, dtype=torch.long)
final_mat = final_mat.long()
embeddings = self.embeddings_table[final_mat]
return embeddings
class CrossAttention(nn.Module):
def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.,
relative_position=False, temporal_length=None):
super().__init__()
inner_dim = dim_head * heads
| context_dim = default(context_dim, query_dim) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: vita-epfl/social-transmotion
# Path: dataset_jrdb.py
def batch_process_coords(coords, masks, padding_mask, config, modality_selection='traj+2dbox', training=False, multiperson=True):
joints = coords.to(config["DEVICE"])
masks = masks.to(config["DEVICE"])
in_F = config["TRAIN"]["input_track_size"]
in_joints_pelvis = joints[:,:, (in_F-1):in_F, 0:1, :].clone()
in_joints_pelvis_last = joints[:,:, (in_F-2):(in_F-1), 0:1, :].clone()
joints[:,:,:,0] = joints[:,:,:,0] - joints[:,0:1, (in_F-1):in_F, 0]
joints[:,:,:,1:] = (joints[:,:,:,1:] - joints[:,:,(in_F-1):in_F,1:])*0.25 #rescale for BB
B, N, F, J, K = joints.shape
if not training:
if modality_selection=='traj':
joints[:,:,:,1:]=0
elif modality_selection=='traj+2dbox':
pass
else:
print('modality error')
exit()
else:
# augment JRDB traj
joints[:,:,:,0,:3] = getRandomRotatePoseTransform(config)(joints[:,:,:,0,:3])
joints = joints.transpose(1, 2).reshape(B, F, N*J, K)
in_joints_pelvis = in_joints_pelvis.reshape(B, 1, N, K)
in_joints_pelvis_last = in_joints_pelvis_last.reshape(B, 1, N, K)
masks = masks.transpose(1, 2).reshape(B, F, N*J)
in_F, out_F = config["TRAIN"]["input_track_size"], config["TRAIN"]["output_track_size"]
in_joints = joints[:,:in_F].float()
out_joints = joints[:,in_F:in_F+out_F].float()
in_masks = masks[:,:in_F].float()
out_masks = masks[:,in_F:in_F+out_F].float()
return in_joints, in_masks, out_joints, out_masks, padding_mask.float()
# Path: dataset_jrdb.py
def create_dataset(dataset_name, logger, **args):
logger.info("Loading dataset " + dataset_name)
if dataset_name == 'jta_all_visual_cues':
dataset = JtaAllVisualCuesDataset(**args)
elif dataset_name == 'jrdb_2dbox':
dataset = Jrdb2dboxDataset(**args)
else:
raise ValueError(f"Dataset with name '{dataset_name}' not found.")
return dataset
# Path: dataset_jrdb.py
def collate_batch(batch):
joints_list = []
masks_list = []
num_people_list = []
for joints, masks in batch:
joints_list.append(joints)
masks_list.append(masks)
num_people_list.append(torch.zeros(joints.shape[0]))
joints = pad_sequence(joints_list, batch_first=True)
masks = pad_sequence(masks_list, batch_first=True)
padding_mask = pad_sequence(num_people_list, batch_first=True, padding_value=1).bool()
return joints, masks, padding_mask
# Path: model_jrdb.py
def create_model(config, logger):
seq_len = config["MODEL"]["seq_len"]
token_num = config["MODEL"]["token_num"]
nhid=config["MODEL"]["dim_hidden"]
nhead=config["MODEL"]["num_heads"]
nlayers_local=config["MODEL"]["num_layers_local"]
nlayers_global=config["MODEL"]["num_layers_global"]
dim_feedforward=config["MODEL"]["dim_feedforward"]
if config["MODEL"]["type"] == "transmotion":
logger.info("Creating bert model.")
model = TransMotion(tok_dim=seq_len,
nhid=nhid,
nhead=nhead,
dim_feedfwd=dim_feedforward,
nlayers_local=nlayers_local,
nlayers_global=nlayers_global,
output_scale=config["MODEL"]["output_scale"],
obs_and_pred=config["TRAIN"]["input_track_size"] + config["TRAIN"]["output_track_size"],
num_tokens=token_num,
device=config["DEVICE"]
).to(config["DEVICE"]).float()
else:
raise ValueError(f"Model type '{config['MODEL']['type']}' not found")
return model
# Path: utils/utils.py
def create_logger(logdir):
head = '%(asctime)-15s %(message)s'
if logdir != '':
log_file = os.path.join(logdir, 'log.txt')
logging.basicConfig(filename=log_file, format=head)
# output to console as well
logging.getLogger().addHandler(logging.StreamHandler(sys.stdout))
else:
logging.basicConfig(format=head)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
return logger
# Path: evaluate_jrdb.py
import argparse
import torch
import random
import numpy as np
from progress.bar import Bar
from torch.utils.data import DataLoader
from dataset_jrdb import batch_process_coords, create_dataset, collate_batch
from model_jrdb import create_model
from utils.utils import create_logger
def inference(model, config, input_joints, padding_mask, out_len=14):
model.eval()
with torch.no_grad():
pred_joints = model(input_joints, padding_mask)
output_joints = pred_joints[:,-out_len:]
return output_joints
def evaluate_ade_fde(model, modality_selection, dataloader, bs, config, logger, return_all=False, bar_prefix="", per_joint=False, show_avg=False):
in_F, out_F = config['TRAIN']['input_track_size'], config['TRAIN']['output_track_size']
bar = Bar(f"EVAL ADE_FDE", fill="#", max=len(dataloader))
batch_size = bs
batch_id = 0
ade = 0
fde = 0
ade_batch = 0
fde_batch = 0
for i, batch in enumerate(dataloader):
joints, masks, padding_mask = batch
padding_mask = padding_mask.to(config["DEVICE"])
| in_joints, in_masks, out_joints, out_masks, padding_mask = batch_process_coords(joints, masks, padding_mask, config, modality_selection) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: facebookresearch/ca_body
# Path: ca_body/nn/blocks.py
def tile2d(x, size: int):
"""Tile a given set of features into a convolutional map.
Args:
x: float tensor of shape [N, F]
size: int or a tuple
Returns:
a feature map [N, F, size[0], size[1]]
"""
# size = size if isinstance(size, tuple) else (size, size)
# NOTE: expecting only int here (!!!)
return x[:, :, np.newaxis, np.newaxis].expand(-1, -1, size, size)
# Path: ca_body/nn/blocks.py
def weights_initializer(lrelu_slope=0.2):
# pyre-ignore
def init_fn(m):
if isinstance(
m,
(
nn.Conv2d,
nn.Conv1d,
nn.ConvTranspose2d,
nn.Linear,
),
):
gain = nn.init.calculate_gain("leaky_relu", lrelu_slope)
nn.init.kaiming_uniform_(m.weight.data, a=gain)
if hasattr(m, "bias") and m.bias is not None:
nn.init.zeros_(m.bias.data)
else:
logger.debug(f"skipping initialization for {m}")
return init_fn
# Path: ca_body/nn/shadow.py
import logging
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
import ca_body.nn.layers as la
from typing import Optional, Dict
from ca_body.nn.blocks import tile2d, weights_initializer
# Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
# TODO: use shared utils here?
logger = logging.getLogger(__name__)
class ShadowUNet(nn.Module):
def __init__(
self,
uv_size,
ao_mean,
shadow_size,
lrelu_slope=0.2,
beta=1.0,
n_dims=64,
interp_mode="bilinear",
biases=True,
trainable_mean=False,
):
super().__init__()
# this is the size of the output
self.uv_size = uv_size
self.shadow_size = shadow_size
ao_mean = F.interpolate(
th.as_tensor(ao_mean)[np.newaxis],
size=(self.shadow_size, self.shadow_size),
)[0]
if not trainable_mean:
# TODO:
self.register_buffer("ao_mean", ao_mean)
else:
self.register_parameter("ao_mean", th.nn.Parameter(ao_mean))
self.depth = 3
self.lrelu_slope = lrelu_slope
self.interp_mode = interp_mode
self.align_corners = None
if interp_mode == "bilinear":
self.align_corners = False
# the base number of dimensions for the shadow maps
n_dims = n_dims
# TODO: generate this?
self.n_enc_dims = [
(1, n_dims),
(n_dims, n_dims),
(n_dims, n_dims),
(n_dims, n_dims),
]
self.sizes = [shadow_size // (2**i) for i in range(len(self.n_enc_dims))]
logger.debug(f"sizes: {self.sizes}")
self.enc_layers = nn.ModuleList()
for i, size in enumerate(self.sizes):
n_in, n_out = self.n_enc_dims[i]
logger.debug(f"EncoderLayers({i}): {n_in}, {n_out}, {size}")
self.enc_layers.append(
nn.Sequential(
la.Conv2dWNUB(
n_in,
n_out,
kernel_size=3,
height=size,
width=size,
stride=1,
padding=1,
),
nn.LeakyReLU(self.lrelu_slope, inplace=True),
)
)
self.n_dec_dims = [
(n_dims, n_dims),
(n_dims * 2, n_dims),
(n_dims * 2, n_dims),
(n_dims * 2, n_dims),
]
self.dec_layers = nn.ModuleList()
for i in range(len(self.sizes)):
size = self.sizes[-i - 1]
n_in, n_out = self.n_dec_dims[i]
logger.debug(f"DecoderLayer({i}): {n_in}, {n_out}, {size}")
self.dec_layers.append(
nn.Sequential(
la.Conv2dWNUB(
n_in,
n_out,
kernel_size=3,
height=size,
width=size,
stride=1,
padding=1,
),
nn.LeakyReLU(self.lrelu_slope, inplace=True),
)
)
| self.apply(weights_initializer(self.lrelu_slope)) |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: 0x00wolf/hkrsAI
# Path: src/pathfinder.py
class PathFinder:
"""Class that returns an object with necessary paths for runtime operations"""
def __init__(self, cwd: str):
self.cwd = cwd
self.config = f'{self.cwd}/config.json'
self.logs = f'{self.cwd}/logs'
self.prompts = f'{self.cwd}/prompts'
self._first_runtime()
self._prompts_dir_exists()
@staticmethod
def _get_cwd():
"""Fetch the current working directory"""
abs_path = os.path.abspath(__file__)
cwd = os.path.dirname(abs_path)
return cwd
def _first_runtime(self):
"""Initialize the config.json and logs directory if not present at runtime."""
self._init_cfg_json()
self._init_logs_dir()
def _prompts_dir_exists(self):
"""Check to see if the prompts directory is present, or print an error and exit."""
if not os.path.exists(self.prompts):
print('[*] error: prompts directory is missing')
sys.exit()
def _init_cfg_json(self):
"""Generate the config.json file."""
if not os.path.exists(self.config):
self._dump(CONFIG_INIT, self.config)
def _init_logs_dir(self):
"""Generate the logs directory"""
if not os.path.exists(self.logs):
os.makedirs(self.logs)
@staticmethod
def _dump(json_dict, json_file):
"""Dumps a JSON object to a file"""
with open(json_file, 'w') as f:
json.dump(json_dict, f, indent=6)
# Path: src/conversation.py
class Conversation:
messages: list[dict] = dataclasses.field(default_factory=list)
query: str = ''
reply: str = ''
response: dict = dataclasses.field(default_factory=dict)
tokens: int = 0
def start(self, system_prompt: str):
self.messages = [{"role": "system", "content": system_prompt}]
print()
return Conversation(messages=self.messages)
def speak(self, content: str):
self.messages.append({"role": "user", "content": content})
return Conversation(messages=self.messages, query=self.query, reply=self.reply, response=self.response)
def think(self, thought):
if self.query == '':
self.query = thought
else:
self.query = f'{self.query}\n{thought}'
return Conversation(messages=self.messages, query=self.query, reply=self.reply, response=self.response)
def listen(self, gpt: GPT):
"""Function to perform GPT chat completions via the API"""
self.response = gpt.client.chat.completions.create(
model=gpt.model,
messages=self.messages,
temperature=gpt.temperature,
top_p=gpt.top_p,
n=gpt.n,
max_tokens=gpt.max_tokens,
frequency_penalty=gpt.frequency_penalty,
presence_penalty=gpt.presence_penalty,
)
self.reply = self.response.choices[0].message.content
self.tokens = self.response.usage.total_tokens
print(f"\n{self.reply}\n")
self.messages.append({"role": "assistant", "content": self.reply})
return Conversation(messages=self.messages, query=self.query, reply=self.reply, response=self.response)
def breath(self):
return Conversation(messages=self.messages, query='', reply=self.reply, response=self.response)
@staticmethod
def greet():
return Conversation(messages=[], query='', reply='', response=None)
# Path: src/logger.py
import os
import re
import json
from typing import Type
from src.pathfinder import PathFinder
from src.conversation import Conversation
class Logger:
def __init__(self, paths: PathFinder, log_level: int, log_format: str):
"""Logs conversations and saves data at the user's request"""
self.level: int = log_level
self.format: str = log_format
self.paths: Paths = paths
self.number: int = 0
self.file: str = ''
self.savefile: str = ''
self.save_number: int = 0
self.new_log()
@property
def level(self):
return self._level
@level.setter
def level(self, new_value: int):
if 1 != new_value != 2:
raise TypeError
else:
self._level = new_value
@property
def format(self):
return self._format
@format.setter
def format(self, new_value: str):
if new_value == 'txt' or new_value == 'json':
self._format = new_value
else:
self._format = new_value
def new_log(self):
self.number = self._next_number()
self.file = self._new_file()
def _next_number(self):
"""Fetch the next log number from config.json and updates it"""
config_data = self._load(self.paths.config)
self.number = log_num = config_data['log_number']
config_data['log_number'] = self.number + 1
self._dump(config_data, self.paths.config)
return self.number
def _new_file(self):
"""Generates a new logfile relative the current log number"""
while True: # to prevent inadvertently overwriting logs if the value is changed in config.json
self.file = f'{self.paths.logs}/log{self.number}.{self.format}'
try:
with open(self.file, 'x'):
print(f'[*] logfile generated ~ {self.file}')
return self.file
except FileExistsError:
self.number += 1
| def log(self, conversation: Conversation): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: ccurme/chesster
# Path: chesster/app/utils.py
def display_board(board, player_side: chess.Color) -> None:
"""Display board."""
board_size = 360
if player_side == chess.WHITE:
flipped = False
else:
flipped = True
if board.move_stack:
last_move = board.move_stack[-1]
else:
last_move = None
return chess.svg.board(board, flipped=flipped, size=board_size, lastmove=last_move)
# Path: chesster/app/utils.py
def get_engine_score(board: chess.Board, player_side: chess.Color) -> int:
"""Get board score in centipawns."""
engine = get_stockfish_engine()
analysis = engine.analyse(board, chess.engine.Limit(time=0.1))
engine.quit()
score = analysis["score"]
if player_side == chess.WHITE:
return score.white().score()
else:
return score.black().score()
# Path: chesster/app/utils.py
def serialize_board_state_with_last_move(
board: chess.Board, player_side: chess.Color
) -> str:
"""Make message capturing board state."""
board_state_str = f"""
Player is playing as {serialize_player_side(player_side)}.
Current board state:
{serialize_board_state(board, player_side)}
"""
if board.move_stack:
last_move = board.pop()
last_move_san = board.san(last_move)
board.push(last_move)
if board.turn == player_side:
last_to_move = "Opponent"
else:
last_to_move = "Player"
previous_move_str = f"""{last_to_move} last move:
{last_move_san}
"""
else:
previous_move_str = "No moves yet."
return _clean_up_prompt(
f"""
{board_state_str}
{previous_move_str}
"""
).strip()
# Path: chesster/app/board_manager.py
import os
import urllib
import chess
from typing import Iterator
from fastapi import WebSocket, WebSocketDisconnect
from langserve import RemoteRunnable
from chesster.app.utils import (
display_board,
get_engine_score,
serialize_board_state_with_last_move,
)
LANGSERVE_HOST = os.getenv("LANGSERVE_HOST", "localhost")
LANGSERVE_SECRET = os.getenv("LANGSERVE_SECRET", "secret")
CHAT_HISTORY_LENGTH = 50 # Number of most recent (human, ai) exchanges to retain.
class BoardManager:
def __init__(self):
self.active_websockets: list[WebSocket] = []
self.last_updated_image = None
self.board = chess.Board()
self.player_side = chess.WHITE
self.interesting_move_iterator = None
self.chat_history = []
self.remote_runnable = RemoteRunnable(
f"http://{LANGSERVE_HOST}:8001/chesster", headers={"x-token": LANGSERVE_SECRET}
)
async def set_board(self, board: chess.Board) -> None:
"""Set board."""
self.board = board
await self.update_board(self.board)
async def set_player_side(self, player_side: chess.Color) -> None:
"""Set player side."""
self.player_side = player_side
await self.update_board(self.board)
async def set_interesting_move_iterator(self) -> None:
"""Calculate interesting moves in board's move stack."""
self.interesting_move_iterator = self._interesting_move_iterator()
async def make_move(self, move: chess.Move) -> None:
"""Parse move and update board."""
self.board.push(move)
await self.update_board(self.board)
async def _interesting_move_iterator(
self, centipawn_threshold: int = 100
) -> Iterator[chess.Board]:
"""Make iterator over interesting moves according to Chess engine."""
new_board = chess.Board()
centipawns = 0
for move in self.board.move_stack:
new_board.push(move)
new_centipawns = get_engine_score(new_board, self.player_side)
if new_centipawns is None:
continue
delta = new_centipawns - centipawns
if new_board.turn != self.player_side: # player just moved
if abs(delta) > centipawn_threshold:
await self.update_board(new_board)
yield {
| "board": serialize_board_state_with_last_move( |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: zkarpinski/codeinsight-sdk-python
# Path: codeinsight_sdk/client.py
class CodeInsightClient:
def __init__(self,
base_url: str,
api_token: str,
timeout: int = 60,
verify_ssl: bool = True
):
self.base_url = base_url
self.api_url = f"{base_url}/codeinsight/api"
self.__api_token = api_token
self.__api_headers = {
'Content-Type': 'application/json',
"Authorization": "Bearer %s" % self.__api_token,
"User-Agent": "codeinsight_sdk_python",
}
self.__timeout = timeout
self.__verify_ssl = verify_ssl
def request(self, method, url_part: str, params: dict = None, body: any = None ):
url = f"{self.api_url}/{url_part}"
# Iterate over params and remove any that are None (Empty)
if(params):
for k, v in list(params.items()):
if v is None:
del params[k]
response = requests.request(method, url,
headers=self.__api_headers, params=params, json=body,
timeout=self.__timeout, verify=self.__verify_ssl)
if not response.ok:
logger.error(f"Error: {response.status_code} - {response.reason}", exc_info=True)
logger.error(response.text)
raise CodeInsightError(response)
return response
@property
def projects(self) -> ProjectHandler:
return ProjectHandler(self)
@property
def reports(self) -> ReportHandler:
return ReportHandler(self)
# Coming soon...?
def inventories(self):
raise NotImplementedError("Inventories are not yet implemented")
def vulnerabilites(self):
raise NotImplementedError
def users(self):
raise NotImplementedError
def licenses(self):
raise NotImplementedError
def tasks(self):
raise NotImplementedError
def rules(self):
raise NotImplementedError
def files(self):
raise NotImplementedError
def folders(self):
raise NotImplementedError
def jobs(self):
raise NotImplementedError
def components(self):
raise NotImplementedError
# Path: codeinsight_sdk/exceptions.py
class CodeInsightError(GenericError):
"""Error class for code insight API errors."""
def __init__(self, response: requests.Response):
try:
resp = response.json()
self.code = response.status_code
self.message = resp['Error: ']
self.arguments = resp['Arguments: ']
self.error = resp['Key: ']
self.add_note(f"Arguments: {self.arguments}")
super().__init__("Error: %s - %s" % (self.code, self.message))
except KeyError:
raise ValueError(f"Error parsing response: {resp}")
except json.decoder.JSONDecodeError:
raise ValueError(f"Error decoding response: {resp}")
# Path: tests/test_client.py
import pytest
import logging
import requests_mock
from codeinsight_sdk import CodeInsightClient
from codeinsight_sdk.exceptions import CodeInsightError
logger = logging.getLogger(__name__)
## CHANGE ME ##
TEST_URL = "https://api.revenera.com"
TEST_API_TOKEN = "your_api_token"
class TestCodeInsightClient:
@pytest.fixture
def client(self):
return CodeInsightClient(TEST_URL, TEST_API_TOKEN)
def test_client(self, client):
assert client.base_url == TEST_URL
def test_endpoint_not_found(self, client):
with requests_mock.Mocker() as m:
m.get(f"{TEST_URL}/codeinsight/api/projects", status_code=404)
with pytest.raises(Exception):
client.projects.all()
class TestProjectEndpoints:
@pytest.fixture
def client(self):
return CodeInsightClient(TEST_URL, TEST_API_TOKEN)
def test_create_project(self, client):
project_name = "Test"
with requests_mock.Mocker() as m:
m.post(f"{TEST_URL}/codeinsight/api/projects", text='{"data": {"id":1}}')
project_id = client.projects.create(project_name)
assert project_id == 1
def test_get_all_projects(self, client):
with requests_mock.Mocker() as m:
m.get(f"{TEST_URL}/codeinsight/api/projects", text='{"data": [{"id":1, "name":"Test"}, {"id":2, "name":"Test 2"}]}')
projects = client.projects.all()
assert len(projects) > 0
def test_get_project_id(self, client):
project_name = "Test"
with requests_mock.Mocker() as m:
m.get(f"{TEST_URL}/codeinsight/api/project/id", text='{ "Content: ": 1 }') # Yes, the key is called 'Content: ' ...
project_id = client.projects.get_id(project_name)
assert project_id == 1
def test_get_project_id_invalid(self,client):
project_name = "Invalid_Project"
fake_response_json = """{ "Arguments: " : ["",""],
"Key: ": " InvalidProjectNameParm",
"Error: ": "The project name entered was not found" }
"""
with requests_mock.Mocker() as m:
# Note, the key names end with a colon and space '...: '
m.get(f"{TEST_URL}/codeinsight/api/project/id", text=fake_response_json, status_code=400)
| with pytest.raises(CodeInsightError): |
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: chebupelka8/Engine
# Path: scripts/math.py
class Vec2:
def __init__(self, x: int | float, y: int | float) -> None:
self.__verify(x, y)
self.__x = x
self.__y = y
@staticmethod
def __verify(x, y) -> None:
match x, y:
case x, y if all(map(lambda a: isinstance(a, (int, float)), [x, y])):
...
case _:
raise ValueError("Arguments 'x' and 'y' should be 'int' or 'float'")
@property
def x(self) -> int | float:
return self.__x
@x.setter
def x(self, __value: int | float) -> None:
self.__x = __value
@property
def y(self) -> int | float:
return self.__y
@y.setter
def y(self, __value: int | float) -> None:
self.__y = __value
@property
def xy(self) -> list:
return [self.__x, self.__y]
def __repr__(self) -> str:
return f"Vec2(x={self.__x}, y={self.__y})"
def __getitem__(self, __index) -> int | float:
return [self.__x, self.__y][__index]
def __setitem__(self, __index, __value) -> None:
res = [self.__x, self.__y]
res[__index] = __value
self.__verify(*res)
self.__x, self.__y = res
def __abs__(self):
return Vec2(abs(self.__x), abs(self.__y))
def __add__(self, __other):
if not isinstance(__other, Vec2): raise TypeError("Argument should be 'Vec2'")
return Vec2(self.__x + __other.x, self.__y + __other.y)
def __mul__(self, __other):
if not isinstance(__other, Vec2): raise TypeError("Argument should be 'Vec2'")
return Vec2(self.__x * __other.x, self.__y * __other.y)
# Path: scripts/image.py
class Image:
def __init__(self, __arg: str | pygame.Surface, should_convert: bool = True) -> None:
self.__image = self.__load(__arg)
if should_convert: self.__image = self.__image.convert_alpha()
@classmethod
def __load(cls, __arg: str | pygame.Surface) -> pygame.Surface:
cls.__verify(__arg)
return pygame.image.load(__arg) if isinstance(__arg, str) else __arg
@staticmethod
def __verify(__arg: Any) -> None:
if not type(__arg) in (str, pygame.Surface): raise TypeError(f"Argument should be a string or a 'Surface', not {type(__arg)}")
@property
def image(self) -> pygame.Surface:
return self.__image
@property
def size(self) -> Vec2:
return Vec2(*self.__image.get_size())
@image.setter
def image(self, image: pygame.Surface) -> None:
self.__image = image
def __repr__(self) -> str:
return f"Image(size={self.image.get_size()}, alpha={self.image.get_alpha()})"
# Path: scripts/loop.py
import pygame, sys
from pygame.locals import *
from .math import Vec2
from .image import Image
class WindowLoop:
def __init__(self, __size: Vec2, fps: int = 144) -> None:
pygame.init()
self.__display = pygame.display.set_mode((__size.x, __size.y))
pygame.display.set_caption("Engine: v0.1")
| pygame.display.set_icon(Image("Engine/assets/icon.png").image)
|
You will be given python files from a code repository, with the current file being shown last. Your task is to predict the next line of code in the current file.
NOTE: You should only predict the next line in the current file. Do not produce more than one line, and do not provide any explanation.
====REPOSITORY====
# Repo Name: lxbme/TSPLifesaver
# Path: TSPLifesaver/abc/abc.py
class AbstractPoint(ABC, MutableSequence):
def __delitem__(self, key): ...
def insert(self, index, value): ...
@abstractmethod
def __init__(self,pos):
"""
Init the Point
:param pos:
"""
@property
def name(self):
"""
The name of the Point.
:return: Any
"""
return None
@abstractmethod
def distance_to(self, other: MutableSequence):
"""
Calculate the distance between this Point and another.
:param other:
:return The distance between the:
"""
# Path: TSPLifesaver/abc/abc.py
class AbstractRoute(ABC, MutableSequence):
@abstractmethod
def swap(self, index_1: int, index_2: int) -> None:
"""
This method should swap the positions of the two elements by indexes.
"""
@abstractmethod
def distance(self):
"""
This method should return the total length of the route.
:return Number: The total length of the route:
"""
# Path: TSPLifesaver/structure.py
class BasicRoute(AbstractRoute):
def __init__(self, points: MutableSequence[AbstractPoint], name="BasicRoute"):
self.points = points
self.name = name
def __iter__(self):
return iter(self.points)
def __getitem__(self, item):
return self.points[item]
def __setitem__(self, item, value):
self.points[item] = value
def __delitem__(self, item):
del self.points[item]
def __len__(self):
return len(self.points)
def __str__(self):
string = self.name + "(\n"
for point in self.points:
string += f"{point.name}: {[point[i] for i in range(len(point))]}\n"
string += ")"
return string
def insert(self, index, value):
self.points.insert(index, value)
def distance(self):
"""
Calculates the total distance.
:return:
"""
return sum([pre.distance_to(after) for pre, after in zip(self[:-1], self[1:])])
def swap(self, index_1: int, index_2: int) -> None:
"""
Swaps two points
:param index_1:
:param index_2:
:return:
"""
self[index_1], self[index_2] = self[index_2], self[index_1]
def append(self, value: AbstractPoint):
self.points.append(value)
# Path: TSPLifesaver/structure.py
class PointWithEuclideanDistance(BasicPoint):
def __init__(self, pos: MutableSequence, name: Any = None):
super().__init__(pos, name)
# Path: TSPLifesaver/optimizer.py
class SimulatedAnnealing(AbstractOptimizer):
def __init__(self, initial_route: AbstractRoute, temperature, cooling_rate, min_temperature):
"""
:param initial_route:
:param initial_route:
:param temperature:
:param cooling_rate:
:param min_temperature:
"""
self.current_route = deepcopy(initial_route)
self.best_route = deepcopy(initial_route)
self.temperature = temperature
self.cooling_rate = cooling_rate
self.min_temperature = min_temperature
def optimize(self):
while self.temperature > self.min_temperature:
new_route = deepcopy(self.current_route)
# exchange randomly
i, j = random.sample(range(len(new_route)), 2)
new_route.swap(i, j)
# calc cost
current_cost = self.current_route.distance()
new_cost = new_route.distance()
cost_difference = current_cost - new_cost
# accepting the new result?
if cost_difference > 0 or math.exp(cost_difference / self.temperature) > random.random():
self.current_route = new_route
if new_cost < self.best_route.distance():
self.best_route = new_route
# decrease the temperature
self.temperature *= (1 - self.cooling_rate)
return self.best_route
# Path: TSPLifesaver/tools.py
from typing import Iterable, MutableSequence, Type
from random import shuffle
from copy import deepcopy
from TSPLifesaver.abc import AbstractRoute, AbstractPoint
from TSPLifesaver.structure import BasicRoute, PointWithEuclideanDistance
from TSPLifesaver.optimizer import SimulatedAnnealing
def route_from_sequence(sequence: Iterable[MutableSequence], route: AbstractRoute = BasicRoute([]),
point_class: Type[AbstractPoint] = PointWithEuclideanDistance,
name_offset: int = 1, ) -> AbstractRoute:
"""
:param route: Instances of the AbstractRoute class or its subclasses, defaults to empty instance of BasicRoute
:param name_offset: Index of the name
:param sequence: Sequence containing coordinates
:param point_class: AbstractPoint or its subclasses ,defaults to PointWithEuclideanDistance
:return: a new route
"""
index = name_offset
for pos in sequence:
try:
point = point_class(pos, name=f"{index}")
except:
point = point_class(pos)
route.append(point)
index += 1
return route
def simulated_annealing(route: AbstractRoute, epoch: int = 100, temperature: float = 10000,
cooling_rate: float = 0.03, min_temperature: float = 1,
log: bool = False) -> AbstractRoute:
"""
:param route: Instances of the AbstractRoute class or its subclasses
:param epoch: Number of epochs to simulate, defaults to 100
:param temperature: Temperature of the annealing, defaults to 10000
:param cooling_rate: Cooling rate of the annealing, defaults to 0.03
:param min_temperature: Minimum temperature of the annealing, defaults to 1
:param log: Whether to print the log of the annealing, defaults to False
:return: optimized route
"""
if len(route):
best_route = deepcopy(route)
for i in range(epoch):
if log:
print(f"Running epoch {i} of {epoch}")
shuffle(route)
| opt = SimulatedAnnealing(route, temperature=temperature, |