prefix stringlengths 82 32.6k | middle stringlengths 5 470 | suffix stringlengths 0 81.2k | file_path stringlengths 6 168 | repo_name stringlengths 16 77 | context listlengths 5 5 | lang stringclasses 4
values | ground_truth stringlengths 5 470 |
|---|---|---|---|---|---|---|---|
import asyncio
import websockets
import json
from sentencepiece import SentencePieceProcessor
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
i... | sequence_actual[:, -max_stop_string:])[0] |
next_token = generator.gen_single_token()
# End on stop token
if next_token in stop_tokens:
return held_text, True, full_prompt + built_response, utilized_prompt + built_response, built_response
# Get new text
new_tail = tokenizer.decode(generator.sequence_actual[:, -(max_stop_string + ... | example_ws.py | turboderp-exllama-a544085 | [
{
"filename": "alt_generator.py",
"retrieved_chunk": " if self.remaining_tokens == 0:\n self.sequence_str += self.held_text\n return self.held_text, True\n self.remaining_tokens -= 1\n # Decode the current tail end of the sequence\n old_tail = self.tokenizer... | python | sequence_actual[:, -max_stop_string:])[0] |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | gen_accept_token(batch_token) |
output = tokenizer.decode(generator.sequence[0])
return output
for i in range(10):
alpha = i / 5.0 - 0.4
print()
print(f"--------------------------------------")
print(f"alpha = {alpha:.1f}")
print(f"--------------------------------------")
output = generate_cfg(prompts, alpha, 200)
... | example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "generator.py",
"retrieved_chunk": " logits = self.model.forward(self.sequence[:, -1:], self.cache, lora = self.lora, input_mask = mask)\n self.apply_rep_penalty(logits)\n logits[:, :, self.tokenizer.bos_token_id] = -10000.0\n if constraints is not N... | python | gen_accept_token(batch_token) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from flask import Flask, request
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import os, glob
# Directory containing config.json, tokenizer.model and safetensors file for the model
model_directory = "/mnt/str/models/llama-7b-4bit/"... | settings.token_repetition_penalty_max = 1.176 |
generator.settings.token_repetition_penalty_sustain = config.max_seq_len
generator.settings.temperature = 0.7
generator.settings.top_p = 0.1
generator.settings.top_k = 40
generator.settings.typical = 0.0 # Disabled
outputs = generator.generate_simple(prompt, max_new_tokens = 200)
return... | example_flask.py | turboderp-exllama-a544085 | [
{
"filename": "webui/app.py",
"retrieved_chunk": "def api_delete_session():\n global session\n data = request.get_json()\n session.api_delete_session(data)\n return json.dumps({\"result\": \"ok\"}) + \"\\n\"\n# Set fixed prompt settings\n@app.route(\"/api/set_fixed_prompt\", methods=['POST'])\nd... | python | settings.token_repetition_penalty_max = 1.176 |
import asyncio
import websockets
import json
from sentencepiece import SentencePieceProcessor
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
i... | decode(prompt_ids)[0] |
built_response = ""
remaining_tokens = max_new_tokens
# Settings
stop_strings = []
stop_tokens = []
for t in stop_conditions:
if isinstance(t, int): stop_tokens += [t]
if isinstance(t, str): stop_strings += [t]
held_text = ""
max_stop_string = 2
for ss in stop_s... | example_ws.py | turboderp-exllama-a544085 | [
{
"filename": "alt_generator.py",
"retrieved_chunk": " # stop_conditions: List of strings or integer token IDs that will end the sequence\n # settings: ExLlamaAltGeneratorSettings\n # encode_special_characters: Set to true to tokenize \"</s>\" etc.\n def begin_stream(self, prompt: str, stop_cond... | python | decode(prompt_ids)[0] |
import asyncio
import websockets
import json
from sentencepiece import SentencePieceProcessor
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
i... | gen_begin_reuse(input_ids) |
def stream():
global model, cache, config, generator, tokenizer
global stop_strings, stop_tokens, prompt_ids, held_text, max_stop_string, remaining_tokens
global full_prompt, utilized_prompt, built_response
# Check total response length
if remaining_tokens == 0:
return held_text, True, f... | example_ws.py | turboderp-exllama-a544085 | [
{
"filename": "alt_generator.py",
"retrieved_chunk": " self.sequence_str = self.tokenizer.decode(applied_input_ids)[0] if applied_input_ids.shape[0] < input_ids.shape[0] else prompt\n # Settings\n self.stop_strings = []\n self.stop_tokens = []\n for t in stop_conditions:\n... | python | gen_begin_reuse(input_ids) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | encode(prompts, return_mask = True) |
generator.gen_begin(ids, mask = mask)
# Sampling loop
for _ in range(max_new_tokens):
logits = model.forward(generator.sequence[:, -1:], cache, input_mask = mask)
generator.apply_rep_penalty(logits)
logits = F.log_softmax(logits, dim = -1)
logits_mixed = (1 - alpha) * lo... | example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "generator.py",
"retrieved_chunk": " self.sequence = self.sequence[:, num_tokens:]\n self.gen_begin(self.sequence, mask = mask)\n def gen_num_tokens(self):\n return self.sequence_actual.shape[-1]\n # Simple generator function\n def generate_simple(self, pr... | python | encode(prompts, return_mask = True) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | decode(generator.sequence[0]) |
return output
for i in range(10):
alpha = i / 5.0 - 0.4
print()
print(f"--------------------------------------")
print(f"alpha = {alpha:.1f}")
print(f"--------------------------------------")
output = generate_cfg(prompts, alpha, 200)
print(output[len(prompts[0]):].strip())
| example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "generator.py",
"retrieved_chunk": " logits = self.model.forward(self.sequence[:, -1:], self.cache, lora = self.lora, input_mask = mask)\n self.apply_rep_penalty(logits)\n logits[:, :, self.tokenizer.bos_token_id] = -10000.0\n if constraints is not N... | python | decode(generator.sequence[0]) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
import argparse, sys, os, glob
from torch import version as torch_version
from globals import set_affinity_str
def add_args(parser):
parser.add_argument("-t", "--tokenizer", type = str, help = "Tokenizer model path")
... | calculate_rotary_embedding_base() |
if args.flash_attn:
config.use_flash_attn_2 = True
try:
config.max_input_len = int(args.flash_attn)
except ValueError:
pass
config.matmul_recons_thd = args.matmul_recons_thd
config.fused_mlp_thd = args.fused_mlp_thd
config.sdp_thd = args.sdp_thd
con... | model_init.py | turboderp-exllama-a544085 | [
{
"filename": "example_alt_generator.py",
"retrieved_chunk": " args.lora = os.path.join(args.lora_dir, \"adapter_model.bin\")\n # Model globals\n model_init.set_globals(args)\n # Instantiate model and generator\n config = model_init.make_config(args)\n model = ExLlama(config)\n cach... | python | calculate_rotary_embedding_base() |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import os, glob
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/llama-13b-4bit-128g/"
# Locate files we need within that directory
tokenizer_pat... | generate_simple(prompts, max_new_tokens = 200) |
for line in output:
print("---")
print(line)
| example_batch.py | turboderp-exllama-a544085 | [
{
"filename": "example_basic.py",
"retrieved_chunk": "generator.settings.token_repetition_penalty_max = 1.2\ngenerator.settings.temperature = 0.95\ngenerator.settings.top_p = 0.65\ngenerator.settings.top_k = 100\ngenerator.settings.typical = 0.5\n# Produce a simple generation\nprompt = \"Once upon a time,\"... | python | generate_simple(prompts, max_new_tokens = 200) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
import argparse, sys, os, glob
from torch import version as torch_version
from globals import set_affinity_str
def add_args(parser):
parser.add_argument("-t", "--tokenizer", type = str, help = "Tokenizer model path")
... | set_auto_map(args.gpu_split) |
config.gpu_peer_fix = args.gpu_peer_fix
config.alpha_value = args.alpha
config.calculate_rotary_embedding_base()
if args.flash_attn:
config.use_flash_attn_2 = True
try:
config.max_input_len = int(args.flash_attn)
except ValueError:
pass
config.matmu... | model_init.py | turboderp-exllama-a544085 | [
{
"filename": "example_chatbot.py",
"retrieved_chunk": "print(f\" -- Sequence length: {args.length}\")\nprint(f\" -- Temperature: {args.temperature:.2f}\")\nprint(f\" -- Top-K: {args.top_k}\")\nprint(f\" -- Top-P: {args.top_p:.2f}\")\nprint(f\" -- Min-P: {args.min_p:.2f}\")\nprint(f\" -- Repetition penalty:... | python | set_auto_map(args.gpu_split) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | forward(generator.sequence[:, -1:], cache, input_mask = mask) |
generator.apply_rep_penalty(logits)
logits = F.log_softmax(logits, dim = -1)
logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1]
sampled_token, _ = generator.sample_current(logits_mixed)
if sampled_token.item() == tokenizer.eos_token_id: break
batch_token = sam... | example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "generator.py",
"retrieved_chunk": " self.sequence = self.sequence[:, num_tokens:]\n self.gen_begin(self.sequence, mask = mask)\n def gen_num_tokens(self):\n return self.sequence_actual.shape[-1]\n # Simple generator function\n def generate_simple(self, pr... | python | forward(generator.sequence[:, -1:], cache, input_mask = mask) |
from __future__ import annotations
import pytest
from configzen.errors import ConfigSyntaxError
from configzen.model import ConfigRoute
STRING_DECOMPOSITION_PARAMS = [
("a.b.c", ["a", "b", "c"]),
(r"a\.b.c", ["a.b", "c"]),
("a.b.[c.d]", ["a", "b", "c.d"]),
("[a.b].c.[d.e]", ["a.b", "c", "d.e"]),
... | enter("b") == ConfigRoute("a.b") |
assert ConfigRoute("a").enter(["b", "c"]) == ConfigRoute("a.b.c")
assert ConfigRoute("a").enter(ConfigRoute("b.c")) == ConfigRoute("a.b.c")
assert ConfigRoute("a").enter(ConfigRoute(["b", "c"])) == ConfigRoute("a.b.c")
assert ConfigRoute("a").enter(ConfigRoute("b.[c.d]")) == ConfigRoute("a.b.[c.d]")
... | tests/test_config/test_route.py | bswck-configzen-42ed40f | [
{
"filename": "tests/test_module_wrapping/test_wrapping.py",
"retrieved_chunk": " assert model == MyConfig()\n assert wrapper.a == MyConfig().a\n assert wrapper.b == MyConfig().b\n wrapper.a = \"2137\"\n wrapper.b = \"1337\"\n assert wrapper.a == model.a == 2137\n assert wrapper.b == mo... | python | enter("b") == ConfigRoute("a.b") |
import argparse
import logging
from logging.config import fileConfig
from pathlib import Path
from . import compile, decompile
def parse_args() -> argparse.Namespace:
# create the top-level parser
parser = argparse.ArgumentParser(
description="Decompile|Compile Python source files into bytecode."
... | compile(to_compile=to_compile) |
elif args.command == "decompile":
to_decompile = Path(args.path)
output_path = Path(args.output) if args.output else None
decompile.decompile(to_decompile=to_decompile, output_path=output_path)
def main() -> None:
cli()
if __name__ == "__main__":
main()
| src/pychd/main.py | diohabara-pychd-b1d0a38 | [
{
"filename": "src/pychd/compile.py",
"retrieved_chunk": " parser.add_argument(\"directory\", help=\"Directory to compile\", type=str)\n return parser.parse_args()\ndef compile(to_compile: Path) -> None:\n if to_compile.is_dir():\n logging.info(\"Compiling Python source files...\")\n ... | python | compile(to_compile=to_compile) |
from __future__ import annotations
import contextlib
import functools
from collections.abc import Callable, Coroutine, Iterator
from typing import TYPE_CHECKING, Any, cast, overload
from configzen.model import export_hook, export_model, export_model_async, field_hook
if TYPE_CHECKING:
from configzen.typedefs imp... | dispatch(cls) is export_model_async: |
async def default_async_func(obj: Any, **kwargs: Any) -> Any:
kwargs |= predefined_kwargs
return await obj.export_async(**kwargs)
export_model_async.register(cls, default_async_func)
else:
export_model.register(cls, func)
if export_model_asy... | configzen/decorators.py | bswck-configzen-42ed40f | [
{
"filename": "configzen/model.py",
"retrieved_chunk": " try:\n cast_func = field_hook_registrars.dispatch(cls)\n except KeyError:\n return value\n return cast_func(cls, value)\n field_hook.register = field_hook_registrars.register\n@functools.singledispatch\nde... | python | dispatch(cls) is export_model_async: |
import asyncio
import websockets
import json
from sentencepiece import SentencePieceProcessor
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
i... | set_auto_map('17.615,18.8897') |
config.model_path = model_path # supply path to model weights file
model = ExLlama(config) # create ExLlama instance and load the weights
print(f"Model loaded: {model_path}")
tokenizer = ExLlamaTokenizer(tokenizer_path) # create tokenizer from token... | example_ws.py | turboderp-exllama-a544085 | [
{
"filename": "example_alt_generator.py",
"retrieved_chunk": " # Directory containing model, tokenizer\n model_directory = \"/mnt/str/models/llama-7b-4bit-128g/\"\n # Locate files we need within that directory\n tokenizer_path = os.path.join(model_directory, \"tokenizer.model\")\n model_confi... | python | set_auto_map('17.615,18.8897') |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | sample_current(logits_mixed) |
if sampled_token.item() == tokenizer.eos_token_id: break
batch_token = sampled_token.repeat(2, 1)
generator.gen_accept_token(batch_token)
output = tokenizer.decode(generator.sequence[0])
return output
for i in range(10):
alpha = i / 5.0 - 0.4
print()
print(f"------------... | example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "test_benchmark_inference.py",
"retrieved_chunk": " ids = tokenizer.encode(prompts)\n assert ids.shape[1] < model.config.max_seq_len, f\"Max length {ids.shape[1]} exceeds model limit {model.config.max_seq_len}\"\n mask = ids.ne(tokenizer.pad_token_id)\n # Batched ge... | python | sample_current(logits_mixed) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import torch
import torch.nn.functional as F
import os, glob
import cuda_ext
# Directory containing model, tokenizer, generator
model_directory = "/mnt/str/models/_test_models/TheBloke... | sequence[:, -1:], cache, input_mask = mask) |
generator.apply_rep_penalty(logits)
logits = F.log_softmax(logits, dim = -1)
logits_mixed = (1 - alpha) * logits[0] + alpha * logits[1]
sampled_token, _ = generator.sample_current(logits_mixed)
if sampled_token.item() == tokenizer.eos_token_id: break
batch_token = sam... | example_cfg.py | turboderp-exllama-a544085 | [
{
"filename": "generator.py",
"retrieved_chunk": " self.sequence = self.sequence[:, num_tokens:]\n self.gen_begin(self.sequence, mask = mask)\n def gen_num_tokens(self):\n return self.sequence_actual.shape[-1]\n # Simple generator function\n def generate_simple(self, pr... | python | sequence[:, -1:], cache, input_mask = mask) |
from datetime import datetime
from typing import Dict
import time
import torch
import torch.nn as nn
from torch.nn.parallel.distributed import DistributedDataParallel
import json
import os
from collections import OrderedDict
def save_checkpoint(prefix: str,
net_model, net_optimizer,
... | dump(opt, f, indent="\t") |
return opt
def dprint(*args, local_rank: int = 0, **kwargs) -> None:
if local_rank == 0:
print(*args, **kwargs)
def time_log() -> str:
a = datetime.now()
return f"*" * 48 + f" {a.year:>4}/{a.month:>2}/{a.day:>2} | {a.hour:>2}:{a.minute:>2}:{a.second:>2}\n"
@torch.no_grad()
def compute_p... | utils/common_utils.py | hynnsk-HP-cd48934 | [
{
"filename": "utils/wandb_utils.py",
"retrieved_chunk": "from typing import Dict, Optional\nimport os\nimport wandb\n__all__ = [\"set_wandb\"]\ndef set_wandb(opt: Dict, local_rank: int = 0, force_mode: Optional[str] = None) -> str:\n if local_rank != 0:\n return \"\"\n # opt = opt\n save_di... | python | dump(opt, f, indent="\t") |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | gen_begin(ids) |
next_userprompt = username + ": "
first_round = True
while True:
res_line = bot_name + ":"
res_tokens = tokenizer.encode(res_line)
num_res_tokens = res_tokens.shape[-1] # Decode from here
if first_round and args.botfirst: in_tokens = res_tokens
else:
# Read and format input
... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " held_text = \"\"\n for i in range(self.max_response_tokens):\n # Truncate the past if the next chunk might generate past max_seq_length\n if generator.sequence_actual is not None:\n if generator.sequenc... | python | gen_begin(ids) |
from __future__ import annotations
import os
from appsignal.__about__ import __version__
from appsignal.config import Config, Options
def test_option():
config = Config(Options(active=False, enable_host_metrics=True))
assert config.option("active") is False
assert config.option("enable_host_metrics") i... | update(config.sources["default"]) |
final_options.update(config.sources["system"])
final_options.update(env_options)
assert config.options == final_options
def test_environ_source_bool_is_unset():
config = Config()
assert config.sources["environment"].get("active") is None
assert config.option("active") is None
def test_envi... | tests/test_config.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "src/appsignal/config.py",
"retrieved_chunk": " self.sources = Sources(\n default=self.DEFAULT_CONFIG,\n system=Config.load_from_system(),\n initial=options or Options(),\n environment=Config.load_from_environment(),\n )\n final_... | python | update(config.sources["default"]) |
from datetime import datetime
from typing import Dict
import time
import torch
import torch.nn as nn
from torch.nn.parallel.distributed import DistributedDataParallel
import json
import os
from collections import OrderedDict
def save_checkpoint(prefix: str,
net_model, net_optimizer,
... | load(f, object_pairs_hook=OrderedDict) # noqa |
gpu_list = ','.join(str(x) for x in opt['gpu_ids'])
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ['CUDA_VISIBLE_DEVICES'] = gpu_list
opt['num_gpus'] = len(opt['gpu_ids'])
print('export CUDA_VISIBLE_DEVICES=' + gpu_list)
print('number of GPUs=' + str(opt['num_gpus']))
os.mak... | utils/common_utils.py | hynnsk-HP-cd48934 | [
{
"filename": "model/dino/utils.py",
"retrieved_chunk": " if os.path.isfile(pretrained_weights):\n state_dict = torch.load(pretrained_weights, map_location=\"cpu\")\n if checkpoint_key is not None and checkpoint_key in state_dict:\n print(f\"Take key {checkpoint_key} in provided ... | python | load(f, object_pairs_hook=OrderedDict) # noqa |
from __future__ import annotations
import os
import re
from logging import DEBUG, ERROR, INFO, WARNING
from appsignal.agent import agent
from appsignal.client import Client
def test_client_options_merge_sources():
os.environ["APPSIGNAL_PUSH_API_KEY"] = "some_key"
client = Client(name="MyApp")
assert cli... | active is False |
def test_client_agent_active():
client = Client(active=True, name="MyApp", push_api_key="000")
assert client._config.options["active"] is True
client.start()
assert os.environ.get("_APPSIGNAL_ACTIVE") == "true"
assert agent.active is True
def test_client_active():
client = Client(
... | tests/test_client.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "src/appsignal/cli/demo.py",
"retrieved_chunk": " active=True,\n name=self._name,\n push_api_key=self._push_api_key,\n log_level=\"trace\",\n )\n print(\"Sending example data to AppSignal...\")\n print(f\"Starting AppSignal clien... | python | active is False |
from __future__ import annotations
import os
from appsignal.__about__ import __version__
from appsignal.config import Config, Options
def test_option():
config = Config(Options(active=False, enable_host_metrics=True))
assert config.option("active") is False
assert config.option("enable_host_metrics") i... | options.keys()) |
def test_environ_source():
os.environ["APPSIGNAL_ACTIVE"] = "true"
os.environ["APPSIGNAL_APP_ENV"] = "development"
os.environ["APPSIGNAL_APP_NAME"] = "MyApp"
os.environ["APPSIGNAL_BIND_ADDRESS"] = "0.0.0.0"
os.environ["APPSIGNAL_CA_FILE_PATH"] = "/path/to/cacert.pem"
os.environ["APPSIGNAL_DNS... | tests/test_config.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "src/appsignal/push_api_key_validator.py",
"retrieved_chunk": " \"name\": config.option(\"name\"),\n \"environment\": config.option(\"environment\"),\n \"hostname\": config.option(\"hostname\") or \"\",\n }\n )\n url = f\"{e... | python | options.keys()) |
from __future__ import annotations
import os
import re
from logging import DEBUG, ERROR, INFO, WARNING
from appsignal.agent import agent
from appsignal.client import Client
def test_client_options_merge_sources():
os.environ["APPSIGNAL_PUSH_API_KEY"] = "some_key"
client = Client(name="MyApp")
assert cli... | _logger.getEffectiveLevel() == INFO |
client = Client(log_level="info")
assert client._logger.getEffectiveLevel() == INFO
def test_logger_error_level():
client = Client(log_level="error")
assert client._logger.getEffectiveLevel() == ERROR
def test_logger_warning_level():
client = Client(log_level="warning")
assert client._logg... | tests/test_client.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "tests/test_config.py",
"retrieved_chunk": " config.set_private_environ()\n assert os.environ[\"_APPSIGNAL_LOG_FILE_PATH\"] == \"/tmp/appsignal.log\"\ndef test_set_private_environ_bool_is_none():\n config = Config(Options(active=None))\n config.set_private_environ()\n assert os.... | python | _logger.getEffectiveLevel() == INFO |
from __future__ import annotations
import sys
from argparse import ArgumentParser
from typing import Mapping, NoReturn
from .command import AppsignalCLICommand
from .demo import DemoCommand
from .diagnose import DiagnoseCommand
from .install import InstallCommand
from .version import VersionCommand
COMMANDS: Mappin... | init_parser(subparser) | src/appsignal/cli/base.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "src/appsignal/cli/command.py",
"retrieved_chunk": " @staticmethod\n def init_parser(parser: ArgumentParser) -> None:\n parser.add_argument(\n \"--push-api-key\",\n default=os.environ.get(\"APPSIGNAL_PUSH_API_KEY\"),\n help=\"Push API Key\",\n ... | python | init_parser(subparser) | |
from __future__ import annotations
import logging
import sys
from logging import DEBUG, ERROR, INFO, WARNING, Logger
from typing import TYPE_CHECKING, ClassVar
from .agent import agent
from .config import Config, Options
from .opentelemetry import start_opentelemetry
if TYPE_CHECKING:
from typing_extensions imp... | option("active"): |
self._logger.info("AppSignal not starting: no active config found")
def start(self) -> None:
if self._config.option("active"):
self._logger.info("Starting AppSignal")
agent.start(self._config)
start_opentelemetry(self._config)
def start_logger(self) -> ... | src/appsignal/client.py | appsignal-appsignal-python-5a0cfa9 | [
{
"filename": "tests/test_client.py",
"retrieved_chunk": "from __future__ import annotations\nimport os\nimport re\nfrom logging import DEBUG, ERROR, INFO, WARNING\nfrom appsignal.agent import agent\nfrom appsignal.client import Client\ndef test_client_options_merge_sources():\n os.environ[\"APPSIGNAL_PU... | python | option("active"): |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | gen_feed_tokens(in_tokens) |
# Generate with streaming
print(res_line, end = "")
sys.stdout.flush()
generator.begin_beam_search()
for i in range(max_response_tokens):
# Disallowing the end condition tokens seems like a clean way to force longer replies.
if i < min_response_tokens:
generator.di... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "alt_generator.py",
"retrieved_chunk": " self.cache.current_seq_len = reuse - 1\n self.sequence_ids = in_tokens[:, :reuse]\n if reuse < in_tokens.shape[-1]: self.gen_feed_tokens(in_tokens[:, reuse:], gen_settings)\n def gen_feed_tokens(self, in_tokens, gen_settings):\n ... | python | gen_feed_tokens(in_tokens) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | gen_prune_to(config.max_seq_len - expect_tokens - extra_prune, tokenizer.newline_token_id) |
# Feed in the user input and "{bot_name}:", tokenized
generator.gen_feed_tokens(in_tokens)
# Generate with streaming
print(res_line, end = "")
sys.stdout.flush()
generator.begin_beam_search()
for i in range(max_response_tokens):
# Disallowing the end condition tokens seems li... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " if gen_token.item() == tokenizer.eos_token_id:\n generator.replace_last_token(tokenizer.newline_token_id)\n # Decode current line to get new characters added (decoding a single token gives incorrect results\n ... | python | gen_prune_to(config.max_seq_len - expect_tokens - extra_prune, tokenizer.newline_token_id) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | gen_num_tokens() >= max_tokens: |
generator.gen_prune_to(config.max_seq_len - expect_tokens - extra_prune, tokenizer.newline_token_id)
# Feed in the user input and "{bot_name}:", tokenized
generator.gen_feed_tokens(in_tokens)
# Generate with streaming
print(res_line, end = "")
sys.stdout.flush()
generator.begin_bea... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " if gen_token.item() == tokenizer.eos_token_id:\n generator.replace_last_token(tokenizer.newline_token_id)\n # Decode current line to get new characters added (decoding a single token gives incorrect results\n ... | python | gen_num_tokens() >= max_tokens: |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | disallow_tokens([tokenizer.newline_token_id, tokenizer.eos_token_id]) |
else:
generator.disallow_tokens(None)
# Get a token
gen_token = generator.beam_search()
# If token is EOS, replace it with newline before continuing
if gen_token.item() == tokenizer.eos_token_id:
generator.replace_last_token(tokenizer.newline_token_id... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "example_alt_generator.py",
"retrieved_chunk": " chunk, eos = generator.stream()\n print(chunk, end = \"\")\n sys.stdout.flush()\n if eos: break",
"score": 38.04205457342302
},
{
"filename": "example_alt_generator.py",
"retrieved_chunk": "settings.lora = lora\npromp... | python | disallow_tokens([tokenizer.newline_token_id, tokenizer.eos_token_id]) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | decode(generator.sequence_actual[:, -num_res_tokens:][0]) |
new_text = text[len(res_line):]
skip_space = res_line.endswith("\n") and new_text.startswith(" ") # Bit prettier console output
res_line += new_text
if skip_space: new_text = new_text[1:]
print(new_text, end="") # (character streaming output is here)
sys.stdout.flush... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " if gen_token.item() == tokenizer.eos_token_id:\n generator.replace_last_token(tokenizer.newline_token_id)\n # Decode current line to get new characters added (decoding a single token gives incorrect results\n ... | python | decode(generator.sequence_actual[:, -num_res_tokens:][0]) |
from model import ExLlama, ExLlamaCache, ExLlamaConfig
from lora import ExLlamaLora
from tokenizer import ExLlamaTokenizer
from generator import ExLlamaGenerator
import argparse
import torch
import sys
import os
import glob
import model_init
# Simple interactive chatbot script
torch.set_grad_enabled(False)
torch.cuda... | sequence_actual[:, -num_res_tokens:][0]) |
new_text = text[len(res_line):]
skip_space = res_line.endswith("\n") and new_text.startswith(" ") # Bit prettier console output
res_line += new_text
if skip_space: new_text = new_text[1:]
print(new_text, end="") # (character streaming output is here)
sys.stdout.flush... | example_chatbot.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " if gen_token.item() == tokenizer.eos_token_id:\n generator.replace_last_token(tokenizer.newline_token_id)\n # Decode current line to get new characters added (decoding a single token gives incorrect results\n ... | python | sequence_actual[:, -num_res_tokens:][0]) |
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from model import ExLlama, ExLlamaConfig
from flask import Flask, render_template, request, jsonify
from flask import Response, stream_with_context
from threading import Timer, Lock
import webbrowser
import json
import mod... | api_populate() |
# Edit block
@app.route("/api/edit_block", methods=['POST'])
def api_edit_block():
global session
data = request.get_json()
session.api_edit_block(data)
return json.dumps({"result": "ok"}) + "\n"
# Delete block
@app.route("/api/delete_block", methods=['POST'])
def api_delete_block():
global ses... | webui/app.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " return False\n os.remove(old_filename)\n return True\n def api_delete_session(self, data):\n delete_name = data[\"session\"]\n delete_name_safe = self._sanitize_filename(delete_name)\n delete_path = _sess... | python | api_populate() |
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from model import ExLlama, ExLlamaConfig
from flask import Flask, render_template, request, jsonify
from flask import Response, stream_with_context
from threading import Timer, Lock
import webbrowser
import json
import mod... | respond_multi(user_input)), mimetype = 'application/json') |
return result
@app.route("/api/append_block", methods=['POST'])
def api_append_block():
data = request.get_json()
session.api_append_block(data)
return json.dumps({"result": "ok"}) + "\n"
# Load the model
parser = argparse.ArgumentParser(description="Simple web-based chatbot for ExLlama")
parser... | webui/app.py | turboderp-exllama-a544085 | [
{
"filename": "webui/session.py",
"retrieved_chunk": " return False\n os.remove(old_filename)\n return True\n def api_delete_session(self, data):\n delete_name = data[\"session\"]\n delete_name_safe = self._sanitize_filename(delete_name)\n delete_path = _sess... | python | respond_multi(user_input)), mimetype = 'application/json') |
import os
import logging
from whatsapp import WhatsApp, Message
from dotenv import load_dotenv
from flask import Flask, request, Response
# Initialize Flask App
app = Flask(__name__)
# Load .env file
load_dotenv("../.env")
messenger = WhatsApp(os.getenv("TOKEN"),
phone_number_id=os.getenv("ID"))
... | get_delivery(data) |
if delivery:
logging.info(f"Message : {delivery}")
else:
logging.info("No new message")
return "OK", 200
if __name__ == "__main__":
app.run(port=6869, debug=False)
| examples/standalone_hook.py | filipporomani-whatsapp-b2c7ba4 | [
{
"filename": "examples/example_hook_obj.py",
"retrieved_chunk": " if file is None:\n return Response(status=400)\n file_id, mime_type = file[\"id\"], file[\"mime_type\"]\n file_url = messenger.query_media_url(file_id)\n if file_url is None:\n return Respons... | python | get_delivery(data) |
import sys
import os
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from model import ExLlama, ExLlamaConfig
from flask import Flask, render_template, request, jsonify
from flask import Response, stream_with_context
from threading import Timer, Lock
import webbrowser
import json
import mod... | print_options(args) |
config = model_init.make_config(args)
model_init.set_globals(args)
print(f" -- Loading model...")
model = ExLlama(config)
print(f" -- Loading tokenizer...")
tokenizer = ExLlamaTokenizer(args.tokenizer)
model_init.print_stats(model)
# Get the session ready
prepare_sessions(model, tokenizer, args.sessions_dir)
ses... | webui/app.py | turboderp-exllama-a544085 | [
{
"filename": "example_chatbot.py",
"retrieved_chunk": "parser.add_argument(\"-beams\", \"--beams\", type = int, help = \"Number of beams for beam search\", default = 1)\nparser.add_argument(\"-beamlen\", \"--beam_length\", type = int, help = \"Number of future tokens to consider\", default = 1)\nargs = par... | python | print_options(args) |
from whatsapp import Message, Hook, WhatsApp
from flask import Response
from os import getenv
from dotenv import load_dotenv
def handler(msg: Message):
message_type = msg.type
messenger = msg.instance
mobile = msg.sender
if message_type == "text":
message = msg.content
name = msg.name... | run() | examples/example_hook_obj.py | filipporomani-whatsapp-b2c7ba4 | [
{
"filename": "examples/standalone_hook.py",
"retrieved_chunk": " file_id, mime_type = file[\"id\"], file[\"mime_type\"]\n file_url = messenger.query_media_url(file_id)\n if file_url is None:\n return Response(status=400)\n file_... | python | run() | |
#!/usr/bin/env python
import pytorch_lightning as pl
import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), "../data"))
sys.path.append(os.path.join(os.path.dirname(__file__), "../model"))
import os
_data_base = '../'
from model_mms import MultimodalTransformer
from data_laoder import MMSDatase... | load_from_checkpoint(CKPT_PATH) |
trainer.validate(model, dataloaders=test_loader, ckpt_path=CKPT_PATH)
| MultiSum/src/runtime/test_mms_model.py | Jason-Qiu-MultiSum_model-c4c58dd | [
{
"filename": "MultiSum/src/runtime/train_mms_model.py",
"retrieved_chunk": " logger=tb_logger,\n log_every_n_steps=50,\n val_check_interval=1.0,\n gradient_clip_val=5,\n accumulate_grad_batches=16,\n callbacks=[ROUGE_RAW_L_checkpoint, ROUGE_RAW_L_stop],\n)\nmodel = MultimodalTransformer(\... | python | load_from_checkpoint(CKPT_PATH) |
import numpy as np
import unittest
from hypothesis import given
from tests.strategies import objects, adapted_function, finite_functions, permutations, parallel_permutations, parallel_arrows
from yarrow.numpy import FiniteFunction
from yarrow.finite_function import argsort
from tests.util import sorts
# Invert a per... | cointerleave(n) |
i = FiniteFunction.identity(2*n)
assert a >> b == i
assert b >> a == i
# Cointerleaving is the opposite of interleaving, and has a more meaningful
# interpretation which we can test easily.
@given(fg=parallel_arrows())
def test_cointerleave(fg):
f, g = fg
N = f.source
assert N == g.source # s... | tests/test_permutations.py | yarrow-id-diagrams-9cbd653 | [
{
"filename": "yarrow/finite_function.py",
"retrieved_chunk": " \"\"\"\n Given a finite function ``f : A → B``\n Return the *stable* sorting permutation ``p : A → A``\n such that ``p >> f`` is monotonic.\n \"\"\"\n... | python | cointerleave(n) |
import numpy as np
import unittest
from hypothesis import given
from tests.strategies import objects, adapted_function, finite_functions, permutations, parallel_permutations, parallel_arrows
from yarrow.numpy import FiniteFunction
from yarrow.finite_function import argsort
from tests.util import sorts
# Invert a per... | interleave(n) |
b = FiniteFunction.cointerleave(n)
i = FiniteFunction.identity(2*n)
assert a >> b == i
assert b >> a == i
# Cointerleaving is the opposite of interleaving, and has a more meaningful
# interpretation which we can test easily.
@given(fg=parallel_arrows())
def test_cointerleave(fg):
f, g = fg
N ... | tests/test_permutations.py | yarrow-id-diagrams-9cbd653 | [
{
"filename": "yarrow/finite_function.py",
"retrieved_chunk": " \"\"\"\n Given a finite function ``f : A → B``\n Return the *stable* sorting permutation ``p : A → A``\n such that ``p >> f`` is monotonic.\n \"\"\"\n... | python | interleave(n) |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'run_detector'
__author__ = 'LuYuan'
__time__ = '2023/2/1 16:25'
__info__ =
"""
from common.classes import Request4AD
from common.request_builder import RequestBuilder
from handlers.detect_handlers import ColdStartDetectHandler, DynamicThresholdDetectHandler
def run_... | build_req() |
# Maps the request to the appropriate handler based on the data by day
target_handler = handler_mapper(req=req)
# Runs the detection pipeline using the target handler
resp = target_handler(req).run()
# Returns the result message from the response
return resp.get_msg()
def handler_mapper(req: ... | handlers/run_main.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "common/request_builder.py",
"retrieved_chunk": "from common.utils import Utils\nclass RequestBuilder:\n def __init__(self, input_body: dict):\n self.body = input_body\n self.req = None\n def build_req(self):\n \"\"\"\n Builds and returns an AD request object ... | python | build_req() |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'outlier_detector'
__author__ = 'LuYuan'
__time__ = '2023/4/13 15:43'
__info__ =
"""
from typing import List
from common.constants import Constants
from common.utils import Utils
RATE = 2
class SimilarityFilter:
def __init__(self, detect_data: List[float], algo... | agg_diff_fe_calc(self.detect_data, self.anomaly_duration) |
if agg_list[-1] < RATE * min(agg_list[:-self.anomaly_duration]):
return False
return True
def minus_data(self, input_data: List[float]) -> List[float]:
"""
If the algorithm is "up", invert the input data.
:param input_data: List of input data.
:return: ... | algorithm/cold_start/similarity_filter.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "algorithm/cs_module.py",
"retrieved_chunk": " def filter(self, status: StatusInOut) -> StatusInOut:\n \"\"\"\n Filters out false positives in the input data\n :param status: The current status object\n :return: The updated status object\n \"\"\"\n ... | python | agg_diff_fe_calc(self.detect_data, self.anomaly_duration) |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'anomaly_detector'
__author__ = 'LuYuan'
__time__ = '2023/4/17 13:35'
__info__ =
"""
from typing import List, Dict
from algorithm.dyn_thresh.dyn_thresh_algo.features import Features
from algorithm.dyn_thresh.dyn_thresh_algo.threshold import ThresholdCalc
from common.c... | diff_percentile_func(self.detect_data, int(k), is_down)[-1] |
target_th = ThresholdCalc(v).run()
if cur_fe < target_th:
return True
else:
target_th = ThresholdCalc(features).run()
if self.detect_data[-1] < target_th:
return True
return False
def minus_data(self):
... | algorithm/dyn_thresh/dyn_thresh_detector.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "algorithm/dyn_thresh/dyn_thresh_algo/features.py",
"retrieved_chunk": " features[k] = Utils.diff_percentile_func(v, duration, is_down)\n return features\n def waveform_smoothness_checker(self):\n \"\"\"\n Evaluate the smoothness of a time series.\n @r... | python | diff_percentile_func(self.detect_data, int(k), is_down)[-1] |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'outlier_detector'
__author__ = 'LuYuan'
__time__ = '2023/4/13 15:43'
__info__ =
"""
import numpy as np
from typing import List
from common.constants import Constants
from common.utils import Utils
class DiffOutlierDetector:
def __init__(self, detect_data: List... | diff_feature_calc(detect_data, self.default_point) |
down_threshold = Utils.turkey_box_plot(detect_data_diff, self.tk_delta)[3]
cp_indexes = []
for index, value in enumerate(detect_data_diff):
if value < down_threshold:
cp_indexes.append(index)
cp_indexes = [c_i for c_i in cp_indexes if c_i > len(detect_data) -... | algorithm/cold_start/diff_outlier_detector.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "common/utils.py",
"retrieved_chunk": "from typing import List, Dict, Callable, Any\nclass Utils:\n def diff_feature_calc(self, input_data: List[float], search_length: int) -> list:\n \"\"\"\n Calculates the difference feature for a given input list.\n :param input_data... | python | diff_feature_calc(detect_data, self.default_point) |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'outlier_detector'
__author__ = 'LuYuan'
__time__ = '2023/4/13 15:43'
__info__ =
"""
import numpy as np
from typing import List
from common.constants import Constants
from common.utils import Utils
class DiffOutlierDetector:
def __init__(self, detect_data: List... | turkey_box_plot(detect_data_diff, self.tk_delta)[3] |
cp_indexes = []
for index, value in enumerate(detect_data_diff):
if value < down_threshold:
cp_indexes.append(index)
cp_indexes = [c_i for c_i in cp_indexes if c_i > len(detect_data) - self.alarm_last_time]
return cp_indexes, down_threshold
def minus_dat... | algorithm/cold_start/diff_outlier_detector.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "common/utils.py",
"retrieved_chunk": "from typing import List, Dict, Callable, Any\nclass Utils:\n def diff_feature_calc(self, input_data: List[float], search_length: int) -> list:\n \"\"\"\n Calculates the difference feature for a given input list.\n :param input_data... | python | turkey_box_plot(detect_data_diff, self.tk_delta)[3] |
"""
__project__ = 'holoinsight-ai'
__file_name__ = 'threshold'
__author__ = 'LuYuan'
__time__ = '2023/4/16 19:27'
__info__ =
"""
from typing import List, Dict
import pandas as pd
import numpy as np
from algorithm.dyn_thresh.dyn_thresh_algo.events import PeriodicEventDetector
from algorithm.dyn_thresh.dyn_thresh_algo.... | turkey_box_plot([freq[k] for k in search_range])[4] |
up_threshold = max(1 / 3 * max([freq[k] for k in search_range]), up_threshold)
index_in = []
for i, v in enumerate(freq):
if v > up_threshold and i in search_range:
index_in.append(i)
potential_index = []
for v in index_in:
if v != max(ind... | algorithm/dyn_thresh/dyn_thresh_algo/threshold.py | traas-stack-holoinsight-ai-b235643 | [
{
"filename": "algorithm/dyn_thresh/dyn_thresh_algo/events.py",
"retrieved_chunk": " @param lst: The list of events to cluster.\n @param count: The maximum number of clusters to create.\n @param interval: The time interval to use for clustering.\n @return: The clustered events as... | python | turkey_box_plot([freq[k] for k in search_range])[4] |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import TDMRepHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class TDMRepTest(TestCase):
@c... | exceptions.TDMRepNoParam, self.rule.is_allowed, None, None) |
self.assertRaises(dd.exceptions.HttpUnknownHeaderObject, self.rule.get_header_value, None, None)
self.assertRaises(dd.exceptions.HttpUnknownResponseObject, self.rule.get_header_value_from_response, None, None)
def test_url_arg(self):
self.assertTrue(self.rule.is_allowed(url="http://localho... | tests/test_tdmrep_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_xrobots_header.py",
"retrieved_chunk": " self.assertFalse(self.rule.is_allowed(response=response))\n self.assertFalse(self.rule.is_allowed(headers=response.headers))\n response = requests.get(\"http://localhost:5001/ai\")\n self.assertEqual(self.rule.get... | python | exceptions.TDMRepNoParam, self.rule.is_allowed, None, None) |
"""
Rules to manage validation using HTTP properties
"""
from ..exceptions import XRobotsTagNoParam, TDMRepNoParam
from .base import HttpRule
class XRobotsTagHeader(HttpRule):
"""
This class wraps logic to read the X-Robots-Tag header.
"""
AI_DISALLOWED_VALUES = ["noai", "noimageai"]
INDEX_DISALL... | get_header_value(headers, self.HEADER_NAME) |
elif response:
header_value = self.get_header_value_from_response(response, self.HEADER_NAME)
elif url:
response = self._handle_url(url)
header_value = self.get_header_value(response.headers, self.HEADER_NAME)
else:
raise XRobotsTagNoParam()
... | src/datadiligence/rules/http.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "src/datadiligence/evaluators/postprocess.py",
"retrieved_chunk": " self.add_rule(XRobotsTagHeader(user_agent))\n self.add_rule(TDMRepHeader())\n def is_allowed(self, **kwargs):\n \"\"\"Check if the headers are allowed based on the rules in this evaluator.\n Args... | python | get_header_value(headers, self.HEADER_NAME) |
"""
Rules to manage validation using HTTP properties
"""
from ..exceptions import XRobotsTagNoParam, TDMRepNoParam
from .base import HttpRule
class XRobotsTagHeader(HttpRule):
"""
This class wraps logic to read the X-Robots-Tag header.
"""
AI_DISALLOWED_VALUES = ["noai", "noimageai"]
INDEX_DISALL... | get_header_value_from_response(response, self.HEADER_NAME) |
elif url:
response = self._handle_url(url)
header_value = self.get_header_value(response.headers, self.HEADER_NAME)
else:
raise XRobotsTagNoParam()
return self._eval_header_value(header_value, **kwargs)
def _eval_header_value(self, header_value, user_ag... | src/datadiligence/rules/http.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "src/datadiligence/evaluators/postprocess.py",
"retrieved_chunk": " self.add_rule(XRobotsTagHeader(user_agent))\n self.add_rule(TDMRepHeader())\n def is_allowed(self, **kwargs):\n \"\"\"Check if the headers are allowed based on the rules in this evaluator.\n Args... | python | get_header_value_from_response(response, self.HEADER_NAME) |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import XRobotsTagHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class XRobotsTest(TestCase):
... | HEADER_NAME), "noai") |
self.assertEqual(self.rule.get_header_value(response.headers, self.rule.HEADER_NAME), "noai")
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "noai")
self.assertFalse(self.rule.is_allowed(response=response))
self.assertFalse(sel... | tests/test_xrobots_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_tdmrep_header.py",
"retrieved_chunk": " self.assertTrue(self.rule._eval_header_value(None))\n def test_tdm_block(self):\n self.assertFalse(self.rule._eval_header_value(\"1\"))\n self.assertTrue(self.rule._eval_header_value(\"0\"))\n self.assertTrue(se... | python | HEADER_NAME), "noai") |
"""
Rules to manage validation using HTTP properties
"""
from ..exceptions import XRobotsTagNoParam, TDMRepNoParam
from .base import HttpRule
class XRobotsTagHeader(HttpRule):
"""
This class wraps logic to read the X-Robots-Tag header.
"""
AI_DISALLOWED_VALUES = ["noai", "noimageai"]
INDEX_DISALL... | _handle_url(url) |
header_value = self.get_header_value(response.headers, self.HEADER_NAME)
else:
raise XRobotsTagNoParam()
return self._eval_header_value(header_value, **kwargs)
def _eval_header_value(self, header_value, user_agent=None, **kwargs):
"""
Evaluate the header va... | src/datadiligence/rules/http.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_tdmrep_header.py",
"retrieved_chunk": " response = requests.get(\"http://localhost:5001/tdmrep\", timeout=3)\n self.assertEqual(self.rule.get_header_value_from_response(response, self.rule.HEADER_NAME), \"0\")\n self.assertEqual(self.rule.get_header_value(respo... | python | _handle_url(url) |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import TDMRepHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class TDMRepTest(TestCase):
@c... | HEADER_NAME), "0") |
self.assertEqual(self.rule.get_header_value(response.headers, self.rule.HEADER_NAME), "0")
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "0")
self.assertTrue(self.rule.is_allowed(response=response))
self.assertTrue(self.rule.i... | tests/test_tdmrep_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_xrobots_header.py",
"retrieved_chunk": " request = urllib.request.Request(\"http://localhost:5001/ai\", data=None)\n with urllib.request.urlopen(request, timeout=3) as response:\n self.assertEqual(self.rule.get_header_value_from_response(response, self.rule... | python | HEADER_NAME), "0") |
"""
This module contains the HttpEvaluator class.
"""
from .base import Evaluator
from ..rules import XRobotsTagHeader, TDMRepHeader
class HttpEvaluator(Evaluator):
"""
HTTP Evaluator class. Loads XRobotsTagHeader rule by default.
"""
name = "http"
def __init__(self, user_agent=None, respect_rob... | rules.append(XRobotsTagHeader(user_agent)) |
if respect_tdmrep:
self.rules.append(TDMRepHeader())
| src/datadiligence/evaluators/http.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "src/datadiligence/evaluators/preprocess.py",
"retrieved_chunk": " def __init__(self, user_agent=None):\n \"\"\" Load the default rules.\n Args:\n user_agent (str): The user agent to pass on to the rules.\n \"\"\"\n super().__init__()\n self.add... | python | rules.append(XRobotsTagHeader(user_agent)) |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import TDMRepHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class TDMRepTest(TestCase):
@c... | get_header_value(response.headers, self.rule.HEADER_NAME), "0") |
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "0")
self.assertTrue(self.rule.is_allowed(response=response))
self.assertTrue(self.rule.is_allowed(headers=response.headers))
request = urllib.request.Request("http://localhost:5001/b... | tests/test_tdmrep_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_xrobots_header.py",
"retrieved_chunk": " def test_useragent_override(self):\n pass\n def test_stdlib(self):\n request = urllib.request.Request(\"http://localhost:5001/noai\", data=None)\n with urllib.request.urlopen(request, timeout=3) as response:\n ... | python | get_header_value(response.headers, self.rule.HEADER_NAME), "0") |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import XRobotsTagHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class XRobotsTest(TestCase):
... | get_header_value_from_response(response, self.rule.HEADER_NAME), "noai") |
self.assertEqual(self.rule.get_header_value(response.headers, self.rule.HEADER_NAME), "noai")
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "noai")
self.assertFalse(self.rule.is_allowed(response=response))
self.assertFalse(sel... | tests/test_xrobots_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_tdmrep_header.py",
"retrieved_chunk": " self.assertTrue(self.rule._eval_header_value(None))\n def test_tdm_block(self):\n self.assertFalse(self.rule._eval_header_value(\"1\"))\n self.assertTrue(self.rule._eval_header_value(\"0\"))\n self.assertTrue(se... | python | get_header_value_from_response(response, self.rule.HEADER_NAME), "noai") |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import TDMRepHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class TDMRepTest(TestCase):
@c... | get_header_value_from_response(response, self.rule.HEADER_NAME), "0") |
self.assertEqual(self.rule.get_header_value(response.headers, self.rule.HEADER_NAME), "0")
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "0")
self.assertTrue(self.rule.is_allowed(response=response))
self.assertTrue(self.rule.i... | tests/test_tdmrep_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_xrobots_header.py",
"retrieved_chunk": " request = urllib.request.Request(\"http://localhost:5001/ai\", data=None)\n with urllib.request.urlopen(request, timeout=3) as response:\n self.assertEqual(self.rule.get_header_value_from_response(response, self.rule... | python | get_header_value_from_response(response, self.rule.HEADER_NAME), "0") |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import XRobotsTagHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class XRobotsTest(TestCase):
... | get_header_value(response.headers, self.rule.HEADER_NAME), "noai") |
self.assertEqual(self.rule.get_header_value(response.getheaders(), self.rule.HEADER_NAME), "noai")
self.assertFalse(self.rule.is_allowed(response=response))
self.assertFalse(self.rule.is_allowed(headers=response.headers))
request = urllib.request.Request("http://localhost:5... | tests/test_xrobots_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_tdmrep_header.py",
"retrieved_chunk": " self.assertTrue(self.rule._eval_header_value(None))\n def test_tdm_block(self):\n self.assertFalse(self.rule._eval_header_value(\"1\"))\n self.assertTrue(self.rule._eval_header_value(\"0\"))\n self.assertTrue(se... | python | get_header_value(response.headers, self.rule.HEADER_NAME), "noai") |
import requests
import urllib.request
from unittest import TestCase
import datadiligence as dd
from datadiligence.rules import XRobotsTagHeader
import time
# starting local server to echo back headers
from werkzeug.serving import make_server
from server.app import app
import threading
class XRobotsTest(TestCase):
... | exceptions.XRobotsTagNoParam, self.rule.is_allowed, None, None) |
self.assertRaises(dd.exceptions.HttpUnknownHeaderObject, self.rule.get_header_value, None, None)
self.assertRaises(dd.exceptions.HttpUnknownResponseObject, self.rule.get_header_value_from_response, None, None)
def test_url_arg(self):
self.assertTrue(self.rule.is_allowed(url="http://localho... | tests/test_xrobots_header.py | Spawning-Inc-datadiligence-9e949d2 | [
{
"filename": "tests/test_tdmrep_header.py",
"retrieved_chunk": " self.assertTrue(self.rule._eval_header_value(None))\n def test_tdm_block(self):\n self.assertFalse(self.rule._eval_header_value(\"1\"))\n self.assertTrue(self.rule._eval_header_value(\"0\"))\n self.assertTrue(se... | python | exceptions.XRobotsTagNoParam, self.rule.is_allowed, None, None) |
import yaml
import data
import os
class AIConfig:
"""
A class object that contains the configuration information for the AI
Attributes:
ai_name (str): The name of the AI.
ai_role (str): The description of the AI's role.
ai_goals (list): The list of objectives the AI is supposed to ... | load_prompt()}" |
return full_prompt
| scripts/ai_config.py | kabeer11000-autollm-53e7404 | [
{
"filename": "scripts/main.py",
"retrieved_chunk": " with open(config_file, \"w\") as file:\n documents = yaml.dump(config, file)\n prompt = data.load_prompt()\n prompt_start = \"\"\"Your decisions must always be made independently without seeking user assistance. Play to your strengths as ... | python | load_prompt()}" |
import pinecone
from memory.base import MemoryProviderSingleton, get_ada_embedding
class PineconeMemory(MemoryProviderSingleton):
def __init__(self, cfg):
pinecone_api_key = cfg.pinecone_api_key
pinecone_region = cfg.pinecone_region
pinecone.init(api_key=pinecone_api_key, environment=pin... | list_indexes(): |
pinecone.create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type)
self.index = pinecone.Index(table_name)
def add(self, data):
vector = get_ada_embedding(data)
# no metadata here. We may wish to change that long term.
resp = self.index.upsert([(st... | scripts/memory/pinecone.py | kabeer11000-autollm-53e7404 | [
{
"filename": "tests/json_tests.py",
"retrieved_chunk": " }\n },\n \"thoughts\":\n {\n \"text\": \"I suggest we start browsing the repository to find any issues that we can fix.\",\n \"reasoning\": \"Browsing the repository will give us an id... | python | list_indexes(): |
import pinecone
from memory.base import MemoryProviderSingleton, get_ada_embedding
class PineconeMemory(MemoryProviderSingleton):
def __init__(self, cfg):
pinecone_api_key = cfg.pinecone_api_key
pinecone_region = cfg.pinecone_region
pinecone.init(api_key=pinecone_api_key, environment=pin... | create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type) |
self.index = pinecone.Index(table_name)
def add(self, data):
vector = get_ada_embedding(data)
# no metadata here. We may wish to change that long term.
resp = self.index.upsert([(str(self.vec_num), vector, {"raw_text": data})])
_text = f"Inserting data into memory at index:... | scripts/memory/pinecone.py | kabeer11000-autollm-53e7404 | [
{
"filename": "tests/json_tests.py",
"retrieved_chunk": " }\n },\n \"thoughts\":\n {\n \"text\": \"I suggest we start browsing the repository to find any issues that we can fix.\",\n \"reasoning\": \"Browsing the repository will give us an id... | python | create_index(table_name, dimension=dimension, metric=metric, pod_type=pod_type) |
import pinecone
from memory.base import MemoryProviderSingleton, get_ada_embedding
class PineconeMemory(MemoryProviderSingleton):
def __init__(self, cfg):
pinecone_api_key = cfg.pinecone_api_key
pinecone_region = cfg.pinecone_region
pinecone.init(api_key=pinecone_api_key, environment=pin... | Index(table_name) |
def add(self, data):
vector = get_ada_embedding(data)
# no metadata here. We may wish to change that long term.
resp = self.index.upsert([(str(self.vec_num), vector, {"raw_text": data})])
_text = f"Inserting data into memory at index: {self.vec_num}:\n data: {data}"
self.ve... | scripts/memory/pinecone.py | kabeer11000-autollm-53e7404 | [
{
"filename": "scripts/memory/__init__.py",
"retrieved_chunk": " PineconeMemory = None\ndef get_memory(cfg, init=False):\n memory = None\n if cfg.memory_backend == \"pinecone\":\n if not PineconeMemory:\n print(\"Error: Pinecone is not installed. Please install pinecone\"\n ... | python | Index(table_name) |
import time
from dotenv import load_dotenv
from config import Config
import token_counter
from llm_utils import create_chat_completion
cfg = Config()
def create_chat_message(role, content):
"""
Create a chat message with the given role and content.
Args:
role (str): The role of the message sender, e.... | count_message_tokens(current_context, model) |
return next_message_to_add_index, current_tokens_used, insertion_index, current_context
# TODO: Change debug from hardcode to argument
def chat_with_ai(
prompt,
user_input,
full_message_history,
permanent_memory,
token_limit):
"""Interact with the OpenAI API, sending t... | scripts/chat.py | kabeer11000-autollm-53e7404 | [
{
"filename": "scripts/main.py",
"retrieved_chunk": " next_action_count -= 1\n memory_to_add = f\"Assistant Reply: {assistant_reply} \" \\\n f\"\\nResult: {result} \" \\\n f\"\\nHuman Feedback: {user_input} \"\n memory.add(memory_to_add)\n # Check if... | python | count_message_tokens(current_context, model) |
from protorl.agents.base import Agent
import torch as T
import torch.nn.functional as F
class SACAgent(Agent):
def __init__(self, actor_network, critic_network_1, critic_network_2,
value_network, target_value_network, memory, policy,
reward_scale=2, gamma=0.99, actor_lr=3e-4, cri... | gamma * value_ |
q1_old_policy = self.critic_1([states, actions]).view(-1)
q2_old_policy = self.critic_2([states, actions]).view(-1)
critic_1_loss = 0.5 * F.mse_loss(q1_old_policy, q_hat)
critic_2_loss = 0.5 * F.mse_loss(q2_old_policy, q_hat)
critic_loss = critic_1_loss + critic_2_loss
c... | protorl/agents/sac.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/agents/ppo.py",
"retrieved_chunk": " actor_loss -= self.entropy_coefficient * entropy\n self.actor_optimizer.zero_grad()\n actor_loss.mean().backward()\n T.nn.utils.clip_grad_norm_(self.actor.parameters(), 40)\n ... | python | gamma * value_ |
import torch as T
from protorl.agents.base import Agent
from protorl.utils.common import convert_arrays_to_tensors
from protorl.utils.common import calc_adv_and_returns
class PPOAgent(Agent):
def __init__(self, actor_net, critic_net, action_type, memory, policy, N,
gamma=0.99, lr=1E-4, gae_lambda... | memory.sample_buffer(mode='all') |
s, s_, r = convert_arrays_to_tensors([s, s_, r], device=self.device)
with T.no_grad():
values = self.critic(s).squeeze()
values_ = self.critic(s_).squeeze()
adv, returns = calc_adv_and_returns(values, values_, r, d)
for epoch in range(self.n_epochs):
... | protorl/agents/ppo.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/agents/ddpg.py",
"retrieved_chunk": " self.update_network_parameters(self.critic,\n self.target_critic, tau=1.0)\n def choose_action(self, observation):\n state = T.tensor(observation, dtype=T.float, device=self.device)\n m... | python | memory.sample_buffer(mode='all') |
from protorl.agents.base import Agent
import numpy as np
import torch as T
class DQNAgent(Agent):
def __init__(self, eval_net, target_net, memory, policy, use_double=False,
gamma=0.99, lr=1e-4, replace=1000, prioritized=False):
super().__init__(memory, policy, gamma)
self.replace_... | sample_memory(mode='prioritized') |
else:
states, actions, rewards, states_, dones = self.sample_memory()
indices = np.arange(len(states))
q_pred = self.q_eval.forward(states)[indices, actions]
q_next = self.q_next(states_)
q_next[dones] = 0.0
if self.use_double:
q_eval = self.q_e... | protorl/agents/dqn.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/agents/dueling.py",
"retrieved_chunk": " def replace_target_network(self):\n if self.learn_step_counter % self.replace_target_cnt == 0:\n self.update_network_parameters(self.q_eval, self.q_next, tau=1.0)\n def update(self):\n if not self.memory.ready():\... | python | sample_memory(mode='prioritized') |
import numpy as np
from protorl.memory.sum_tree import SumTree
class GenericBuffer:
def __init__(self, max_size, batch_size, fields, prioritized=False):
self.mem_size = max_size
self.mem_cntr = 0
self.batch_size = batch_size
self.fields = fields
self.prioritized = prioritiz... | store_transition() |
def sample_buffer(self, mode='uniform'):
max_mem = min(self.mem_cntr, self.mem_size)
if mode == 'uniform':
batch = np.random.choice(max_mem, self.batch_size, replace=False)
arr = []
for field in self.fields:
arr.append(getattr(self, field)[batch]... | protorl/memory/generic.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/memory/sum_tree.py",
"retrieved_chunk": " replace=False)\n probs = [1 / self.batch_size for _ in range(self.batch_size)]\n return samples, probs\n samples, probs, n_samples = [], [], 1\n index = self.counter % s... | python | store_transition() |
from protorl.agents.base import Agent
import torch as T
import torch.nn.functional as F
class SACAgent(Agent):
def __init__(self, actor_network, critic_network_1, critic_network_2,
value_network, target_value_network, memory, policy,
reward_scale=2, gamma=0.99, actor_lr=3e-4, cri... | update_network_parameters(self.value, self.target_value, tau=1.0) |
def choose_action(self, observation):
state = T.tensor(observation, dtype=T.float).to(self.device)
mu, sigma = self.actor(state)
actions, _ = self.policy(mu, sigma)
return actions.cpu().detach().numpy()
def update(self):
if not self.memory.ready():
return
... | protorl/agents/sac.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/agents/td3.py",
"retrieved_chunk": " self.critic_2,\n self.target_actor,\n self.target_critic_1,\n self.target_critic_2]]\n ... | python | update_network_parameters(self.value, self.target_value, tau=1.0) |
from protorl.agents.base import Agent
import torch as T
import torch.nn.functional as F
class SACAgent(Agent):
def __init__(self, actor_network, critic_network_1, critic_network_2,
value_network, target_value_network, memory, policy,
reward_scale=2, gamma=0.99, actor_lr=3e-4, cri... | policy(mu, sigma) |
return actions.cpu().detach().numpy()
def update(self):
if not self.memory.ready():
return
states, actions, rewards, states_, dones = self.sample_memory()
value = self.value(states).view(-1)
value_ = self.target_value(states_).view(-1)
value_[dones] = ... | protorl/agents/sac.py | philtabor-ProtoRL-31f81e7 | [
{
"filename": "protorl/agents/ppo.py",
"retrieved_chunk": " self.actor_optimizer = T.optim.Adam(self.actor.parameters(), lr=lr)\n self.critic_optimizer = T.optim.Adam(self.critic.parameters(), lr=lr)\n def choose_action(self, observation):\n state = T.tensor(observation, dtype=T.floa... | python | policy(mu, sigma) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | splitter.addWidget(self.sidebar) |
self.vertex_list = self.create_list_widget(VERTICES, self._vty_clicked)
self.edge_list = self.create_list_widget(EDGES, self._ety_clicked)
self.sidebar.addWidget(self.vertex_list)
self.sidebar.addWidget(self.edge_list)
def create_list_widget(self, data: dict[str, DrawPanelNodeType]... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_panel.py",
"retrieved_chunk": "from . import animations as anims\nclass ProofPanel(BasePanel):\n \"\"\"Panel for the proof mode of ZX live.\"\"\"\n def __init__(self, graph: GraphT) -> None:\n self.graph_scene = GraphScene()\n self.graph_scene.vertices_moved.c... | python | splitter.addWidget(self.sidebar) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | edge_added.connect(self._add_edge) |
self._curr_vty = VertexType.Z
self._curr_ety = EdgeType.SIMPLE
super().__init__(graph, self.graph_scene)
self.sidebar = QSplitter(self)
self.sidebar.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.sidebar)
self.vertex_list = self.create_list_widget(VER... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_panel.py",
"retrieved_chunk": "from . import animations as anims\nclass ProofPanel(BasePanel):\n \"\"\"Panel for the proof mode of ZX live.\"\"\"\n def __init__(self, graph: GraphT) -> None:\n self.graph_scene = GraphScene()\n self.graph_scene.vertices_moved.c... | python | edge_added.connect(self._add_edge) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | vertex_added.connect(self._add_vert) |
self.graph_scene.edge_added.connect(self._add_edge)
self._curr_vty = VertexType.Z
self._curr_ety = EdgeType.SIMPLE
super().__init__(graph, self.graph_scene)
self.sidebar = QSplitter(self)
self.sidebar.setOrientation(Qt.Vertical)
self.splitter.addWidget(self.sid... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_panel.py",
"retrieved_chunk": "from . import animations as anims\nclass ProofPanel(BasePanel):\n \"\"\"Panel for the proof mode of ZX live.\"\"\"\n def __init__(self, graph: GraphT) -> None:\n self.graph_scene = GraphScene()\n self.graph_scene.vertices_moved.c... | python | vertex_added.connect(self._add_vert) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | graph_view, selected, vty) |
self.undo_stack.push(cmd)
def _ety_clicked(self, ety: EdgeType.Type) -> None:
self._curr_ety = ety
self.graph_scene.curr_ety = ety
selected = list(self.graph_scene.selected_edges)
if len(selected) > 0:
cmd = ChangeEdgeColor(self.graph_view, selected, ety)
... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/commands.py",
"retrieved_chunk": " def redo(self) -> None:\n self.old_g = self.graph_view.graph_scene.g\n self.old_selected = set(self.graph_view.graph_scene.selected_vertices)\n self.g = self.new_g\n self.update_graph_view(True)\n@dataclass\nclass Change... | python | graph_view, selected, vty) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | VERTEX)) |
self.edge.clicked.connect(lambda: self._tool_clicked(ToolType.EDGE))
yield ToolbarSection(self.select, self.vertex, self.edge, exclusive=True)
self.start_derivation = QToolButton(self, text="Start Derivation")
self.start_derivation.clicked.connect(self._start_derivation)
yield ... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_panel.py",
"retrieved_chunk": " self.selection.setIcon(QIcon(get_data(\"icons/tikzit-tool-select.svg\")))\n self.magic_wand.setIcon(QIcon(get_data(\"icons/magic-wand.svg\")))\n self.selection.setIconSize(icon_size)\n self.magic_wand.setIconSize(icon_si... | python | VERTEX)) |
from typing import List
from pyzx.utils import EdgeType, VertexType
from .common import GraphT, Graph
def construct_circuit() -> GraphT:
qubits = 4
vlist = [
(0, 0, 1), (1, 1, 2), (2, 2, 1), (3, 3, 1), (4, 0, 1), (5, 1, 1),
(6, 2, 2), (7, 3, 1), (8, 0, 1), (9, 1, 2), (10, 2, 1), (11, 3, 1),... | set_inputs(tuple(inputs)) |
g.set_outputs(tuple(outputs))
return g
| zxlive/construct.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_actions.py",
"retrieved_chunk": " v_data = {v: {\"type\": graph.type(v),\n \"phase\": graph.phase(v),}\n for v in graph.vertices()}\n for i, input_vertex in enumerate(graph.inputs()):\n v_data[input_vertex][\"boundary_index\"] = f'input_... | python | set_inputs(tuple(inputs)) |
from hsr_client.datamodels.lightcone import MaterialCount, Lightcone
from hsr_client.datamodels.material import Material
from hsr_client.datamodels.searchItem import SearchItem
from hsr_client.constants import Item
from hsr_client.paths import Path
from hsr_client.constants import MaterialTypes
from hsr_client.backend... | MATERIAL, url='', iconPath='', rarity=0, name='')) |
__mtrls.append(MaterialCount(material=__mtrlobj, count=mtrl['count']))
ascension_mats.append((__lvl, __mtrls))
# prepare actual lightcone.
lightcone = Lightcone(
name=lc_name,
rarity=lc_rarity,
description=lc_description,
path=lc_path,
ability=... | hsr_client/backend/srs_backend/parsers/lightcone.py | reko-beep-hsr-data-c73208a | [
{
"filename": "tests/srs_backend_test.py",
"retrieved_chunk": " srs = SRSBackend()\n mtrl = srs.resolve_material(search_item=SearchItem(url='', iconPath='', type=Item.MATERIAL, name='', rarity=4, id=24001))\n print(mtrl)\nif __name__ == \"__main__\":\n unittest.main()",
"score": ... | python | MATERIAL, url='', iconPath='', rarity=0, name='')) |
from os import listdir, getcwd
from os.path import isdir, isfile, exists
from json import load, dump
from hsr_client.utils import ImageManipulation as img
from PIL import Image
BASE_CHAR = getcwd()+"/characters/"
BASE_MATERIALS = getcwd()+"/materials/"
chars = [f for f in listdir(BASE_CHAR) if isfile(BASE_CHAR+f)]
ma... | create_image_card(name.title(),bytes_, False ,'Ascension', 0, 0, bg_img) |
max_item = 5
start_x = img_.size[0] // 2 - 250
start_y = 250
end_x = start_x + (112*5)
cards_list = cards['levels'] + cards['skills']
rows = 1
for c, card in enumerate(cards_list,1):
count_fix = c
if c > (rows * max_item):
... | ascension.py | reko-beep-hsr-data-c73208a | [
{
"filename": "raw_data.py",
"retrieved_chunk": " with open(f'{save_path}/{language}/{folders[entry.type.name]}/{entry.id}.json', 'w') as f:\n dump(data, f, indent=1)\nprint(f'[downloading] [Language: {language}]', 'ACHIEVEMENTS') \ndata = client.fetch(language, ACHIEVEMENTS, False)\nwit... | python | create_image_card(name.title(),bytes_, False ,'Ascension', 0, 0, bg_img) |
from typing import List
from pyzx.utils import EdgeType, VertexType
from .common import GraphT, Graph
def construct_circuit() -> GraphT:
qubits = 4
vlist = [
(0, 0, 1), (1, 1, 2), (2, 2, 1), (3, 3, 1), (4, 0, 1), (5, 1, 1),
(6, 2, 2), (7, 3, 1), (8, 0, 1), (9, 1, 2), (10, 2, 1), (11, 3, 1),... | add_vertex(ty[i], qu, rw) |
cur_row[qu] += 1
es1 = [edge[:2] for edge in nelist if not edge[2]]
es2 = [edge[:2] for edge in nelist if edge[2]]
# TODO: add the phase part
# for w, phase in phases.items():
# g.set_phase(w,phase)
g.add_edges(es1, EdgeType.SIMPLE)
g.add_edges(es2, EdgeType.HADAMARD)
in... | zxlive/construct.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_actions.py",
"retrieved_chunk": " v_data = {v: {\"type\": graph.type(v),\n \"phase\": graph.phase(v),}\n for v in graph.vertices()}\n for i, input_vertex in enumerate(graph.inputs()):\n v_data[input_vertex][\"boundary_index\"] = f'input_... | python | add_vertex(ty[i], qu, rw) |
import unittest
from hsr_client.backend.srs_backend import SRSBackend
from hsr_client.backend.srs_backend.parsers.trace import parse_trace_data
from hsr_client.datamodels.searchItem import SearchItem
from hsr_client.constants import Item
class Test_backend(unittest.TestCase):
def test_traces(self):
i... | get_character(target_name="march") |
print(chara.name)
def test_mtrl(self):
srs = SRSBackend()
mtrl = srs.resolve_material(search_item=SearchItem(url='', iconPath='', type=Item.MATERIAL, name='', rarity=4, id=24001))
print(mtrl)
if __name__ == "__main__":
unittest.main() | tests/srs_backend_test.py | reko-beep-hsr-data-c73208a | [
{
"filename": "hsr_client/backend/srs_backend/parsers/trace.py",
"retrieved_chunk": " )\n else:\n raise BackendError(\"Invalid trace type(int) found: \", trace_node[\"type\"])\n traces.append(_trace)\n # parse child traces\n children = trace_node.get(\"child... | python | get_character(target_name="march") |
import unittest
from hsr_client.backend.srs_backend import SRSBackend
from hsr_client.backend.srs_backend.parsers.trace import parse_trace_data
from hsr_client.datamodels.searchItem import SearchItem
from hsr_client.constants import Item
class Test_backend(unittest.TestCase):
def test_traces(self):
i... | MATERIAL, name='', rarity=4, id=24001)) |
print(mtrl)
if __name__ == "__main__":
unittest.main() | tests/srs_backend_test.py | reko-beep-hsr-data-c73208a | [
{
"filename": "hsr_client/backend/srs_backend/__init__.py",
"retrieved_chunk": " Item.LIGHTCONE: routes.LIGHTCONES,\n Item.BOOK: routes.BOOKS,\n Item.MATERIAL: routes.MATERIALS,\n}\n# backend for starrail station.\nclass SRSBackend(Backend):\n def __init__(self) -> None:\n super().__init_... | python | MATERIAL, name='', rarity=4, id=24001)) |
from os import listdir, getcwd
from os.path import isdir, isfile, exists
from json import load, dump
from hsr_client.utils import ImageManipulation as img
from PIL import Image
BASE_CHAR = getcwd()+"/characters/"
BASE_MATERIALS = getcwd()+"/materials/"
chars = [f for f in listdir(BASE_CHAR) if isfile(BASE_CHAR+f)]
ma... | create_card_image(card) |
x = start_x + (122 * (count_fix - 1)) + 30
y = start_y + (145 * (rows - 1))+ 30
img_.paste(c_img, (x,y), c_img)
img_ = img_.crop((0,0, 1600, img_.size[1]))
img_ = img.add_corners(img_,45)
img_.show()
img_.save(f"{getcwd()}/ascension/{name}-ascension... | ascension.py | reko-beep-hsr-data-c73208a | [
{
"filename": "hsr_client/utils.py",
"retrieved_chunk": "def logc(*msg):\n stack = inspect.stack()\n class_name = stack[1][0].f_locals[\"self\"].__class__.__name__\n print(f\"[{class_name}] at [{datetime.now().strftime('%c')}] - \", *msg)",
"score": 32.04835219032307
},
{
"filename": "h... | python | create_card_image(card) |
from os import listdir, getcwd
from os.path import isdir, isfile, exists
from json import load, dump
from hsr_client.utils import ImageManipulation as img
from PIL import Image
BASE_CHAR = getcwd()+"/characters/"
BASE_MATERIALS = getcwd()+"/materials/"
chars = [f for f in listdir(BASE_CHAR) if isfile(BASE_CHAR+f)]
ma... | add_corners(img_,45) |
img_.show()
img_.save(f"{getcwd()}/ascension/{name}-ascension.png")
| ascension.py | reko-beep-hsr-data-c73208a | [
{
"filename": "hsr_client/utils.py",
"retrieved_chunk": "def logc(*msg):\n stack = inspect.stack()\n class_name = stack[1][0].f_locals[\"self\"].__class__.__name__\n print(f\"[{class_name}] at [{datetime.now().strftime('%c')}] - \", *msg)",
"score": 24.68880493528338
},
{
"filename": "h... | python | add_corners(img_,45) |
from pydantic import BaseModel, validator, Field, Extra
from typing import Optional
from hsr_client.routes import IMAGE_ROUTE, AUDIO_ROUTE
from hsr_client.constants import Item, _RelicTypes
from hsr_client.datamodels.searchItem import SearchItem
class DamageType(BaseModel):
id : int
iconPath : Optional[str]
... | format(assetId=v) |
return ''
class BaseType(BaseModel):
id : int
iconPath : Optional[str]
altIconPath : Optional[str]
color : Optional[str]
rarity: Optional[int]
name : Optional[str]
@validator('iconPath', pre=True)
def get_icon_path(cls, v):
if v != "":
return IMAGE_RO... | hsr_client/datamodels/character.py | reko-beep-hsr-data-c73208a | [
{
"filename": "hsr_client/datamodels/searchItem.py",
"retrieved_chunk": " name: Optional[str]\n rarity: Optional[int]\n id: Union[int, str]\n class Config:\n extra = Extra.allow\n def available_filters(self):\n \"\"\"TODO: add documentation here\"\"\"\n return [f for f in... | python | format(assetId=v) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | vertex_dragged.connect(self._vertex_dragged) |
self.graph_scene.vertex_dropped_onto.connect(self._vertex_dropped_onto)
self.step_view = QListView(self)
self.proof_model = ProofModel(self.graph_view.graph_scene.g)
self.step_view.setModel(self.proof_model)
self.step_view.setPalette(QColor(255, 255, 255))
self.step_vie... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/edit_panel.py",
"retrieved_chunk": " self.graph_scene.vertices_moved.connect(self._vert_moved)\n self.graph_scene.vertex_double_clicked.connect(self._vert_double_clicked)\n self.graph_scene.vertex_added.connect(self._add_vert)\n self.graph_scene.edge_added.c... | python | vertex_dragged.connect(self._vertex_dragged) |
from typing import List
from pyzx.utils import EdgeType, VertexType
from .common import GraphT, Graph
def construct_circuit() -> GraphT:
qubits = 4
vlist = [
(0, 0, 1), (1, 1, 2), (2, 2, 1), (3, 3, 1), (4, 0, 1), (5, 1, 1),
(6, 2, 2), (7, 3, 1), (8, 0, 1), (9, 1, 2), (10, 2, 1), (11, 3, 1),... | add_edges(es1, EdgeType.SIMPLE) |
g.add_edges(es2, EdgeType.HADAMARD)
inputs = []
outputs = []
for i in range(qubits):
inputs.append(i)
outputs.append(nvertices-qubits+i)
g.set_inputs(tuple(inputs))
g.set_outputs(tuple(outputs))
return g
| zxlive/construct.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/rules.py",
"retrieved_chunk": " nodes.append(node)\n for v in vs:\n for n in g.neighbors(v):\n g.add_edge(g.edge(node, n), EdgeType.SIMPLE) # type: ignore\n g.remove_vertex(v)\n g.add_edge(g.edge(nodes[0], nodes[1]), EdgeType.SIMPLE... | python | add_edges(es1, EdgeType.SIMPLE) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | graph_view.wand_trace_finished.connect(self._wand_trace_finished) |
self.graph_scene.vertex_dragged.connect(self._vertex_dragged)
self.graph_scene.vertex_dropped_onto.connect(self._vertex_dropped_onto)
self.step_view = QListView(self)
self.proof_model = ProofModel(self.graph_view.graph_scene.g)
self.step_view.setModel(self.proof_model)
... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/edit_panel.py",
"retrieved_chunk": " self.graph_scene.vertices_moved.connect(self._vert_moved)\n self.graph_scene.vertex_double_clicked.connect(self._vert_double_clicked)\n self.graph_scene.vertex_added.connect(self._add_vert)\n self.graph_scene.edge_added.c... | python | graph_view.wand_trace_finished.connect(self._wand_trace_finished) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | vertex_dropped_onto.connect(self._vertex_dropped_onto) |
self.step_view = QListView(self)
self.proof_model = ProofModel(self.graph_view.graph_scene.g)
self.step_view.setModel(self.proof_model)
self.step_view.setPalette(QColor(255, 255, 255))
self.step_view.setSpacing(0)
self.step_view.setSelectionMode(QAbstractItemView.Select... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/edit_panel.py",
"retrieved_chunk": " self.graph_scene.vertices_moved.connect(self._vert_moved)\n self.graph_scene.vertex_double_clicked.connect(self._vert_double_clicked)\n self.graph_scene.vertex_added.connect(self._add_vert)\n self.graph_scene.edge_added.c... | python | vertex_dropped_onto.connect(self._vertex_dropped_onto) |
import importlib
import os
import time
import pytest
from dotenv import load_dotenv
import openai_forward
class TestEnv:
with open(".env", "r", encoding="utf-8") as f:
defualt_env = f.read()
@classmethod
def setup_class(cls):
env = """\
LOG_CHAT=true
OPENAI_BASE_URL=https://api.openai.c... | forwarding.openai) |
importlib.reload(openai_forward.forwarding.settings)
cls.aibase = openai_forward.forwarding.openai.OpenaiForwarding(
'https://api.openai.com', '/'
)
@classmethod
def teardown_class(cls):
with open(".env", "w", encoding="utf-8") as f:
f.write(cls.defualt_... | tests/test_env.py | beidongjiedeguang-openai-forward-c2c2757 | [
{
"filename": "tests/test_api.py",
"retrieved_chunk": " assert next(openai._cycle_api_key) == \"a\"\n def test_validate_ip(self, openai: OpenaiForwarding):\n from openai_forward.forwarding.settings import IP_BLACKLIST, IP_WHITELIST\n ip1 = \"1.1.1.1\"\n ip2 = \"2.2.2.2\"\n ... | python | forwarding.openai) |
import copy
from fractions import Fraction
from typing import Iterator, TypedDict, Callable
from PySide6.QtCore import Signal, QSize, Qt
from PySide6.QtWidgets import QToolButton, QInputDialog, QSplitter, QListView, QListWidget, QListWidgetItem
from PySide6.QtGui import QShortcut, QIcon, QPen, QPainter, QColor, QPixma... | select_vertices(new_verts) |
def delete_selection(self) -> None:
selection = list(self.graph_scene.selected_vertices)
selected_edges = list(self.graph_scene.selected_edges)
if not selection and not selected_edges: return
new_g = copy.deepcopy(self.graph_scene.g)
self.graph_scene.clearSelection()
... | zxlive/edit_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_panel.py",
"retrieved_chunk": " new_g.add_edge((neighbor, left_vert),\n self.graph.edge_type((v, neighbor)))\n new_g.remove_edge((v, neighbor))\n new_g.add_edge((v, left_vert))\n if phase_left:\n new_g.set_p... | python | select_vertices(new_verts) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | layout().insertWidget(1, widget) |
def parse_selection(self) -> tuple[list[VT], list[ET]]:
selection = list(self.graph_scene.selected_vertices)
g = self.graph_scene.g
edges = []
for e in g.edges():
s,t = g.edge_st(e)
if s in selection and t in selection:
edges.append(e)
... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_actions.py",
"retrieved_chunk": " def init_buttons(self, parent: \"ProofPanel\") -> None:\n self.btn_group = QButtonGroup(parent, exclusive=False)\n def create_rewrite(action: ProofAction, parent: \"ProofPanel\") -> Callable[[], None]: # Needed to prevent weird b... | python | layout().insertWidget(1, widget) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | rewrites).copy()] |
for group in reversed(self.action_groups):
hlayout = QHBoxLayout()
group.init_buttons(self)
for action in group.actions:
assert action.button is not None
hlayout.addWidget(action.button)
hlayout.addStretch()
widget = Q... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/edit_panel.py",
"retrieved_chunk": " self.vertex.clicked.connect(lambda: self._tool_clicked(ToolType.VERTEX))\n self.edge.clicked.connect(lambda: self._tool_clicked(ToolType.EDGE))\n yield ToolbarSection(self.select, self.vertex, self.edge, exclusive=True)\n ... | python | rewrites).copy()] |
import os
from typing import *
import ffmpeg
import numpy as np
import requests
import torch
from tqdm import tqdm
from lib.rvc.config import TrainConfig
from modules.shared import ROOT_DIR
def load_audio(file: str, sr):
try:
# https://github.com/openai/whisper/blob/main/whisper/audio.py#L26
# T... | parse_file(config_path) |
config.version = version
config.train.fp16_run = fp16
config_save_path = os.path.join(training_dir, "config.json")
with open(config_save_path, "w") as f:
f.write(config.json())
return config
| modules/utils.py | ddPn08-rvc-webui-c4a12a8 | [
{
"filename": "lib/rvc/utils.py",
"retrieved_chunk": "def load_wav_to_torch(full_path):\n sampling_rate, data = read(full_path)\n return torch.FloatTensor(data.astype(np.float32)), sampling_rate\ndef load_config(training_dir: str, sample_rate: int, emb_channels: int):\n if emb_channels == 256:\n ... | python | parse_file(config_path) |
import math
import torch
from torch import nn
from torch.nn import Conv1d
from torch.nn import functional as F
from torch.nn.utils import remove_weight_norm, weight_norm
from . import commons
from .commons import get_padding, init_weights
from .transforms import piecewise_rational_quadratic_transform
LRELU_SLOPE = 0... | fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor) |
acts = self.drop(acts)
res_skip_acts = self.res_skip_layers[i](acts)
if i < self.n_layers - 1:
res_acts = res_skip_acts[:, : self.hidden_channels, :]
x = (x + res_acts) * x_mask
output = output + res_skip_acts[:, self.hidden_channels ... | lib/rvc/modules.py | ddPn08-rvc-webui-c4a12a8 | [
{
"filename": "lib/rvc/models.py",
"retrieved_chunk": " self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)\n def forward(self, x, g=None):\n x = self.conv_pre(x)\n if g is not None:\n x = x + self.cond(g)\n for i in range(self.num_upsamples):\n ... | python | fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor) |
import io
import json
import gradio as gr
import requests
import soundfile as sf
import torch.multiprocessing as multiprocessing
from scipy.io.wavfile import write
from modules.ui import Tab
from server import app
proc = None
def server_options_ui(show_out_dir=True):
with gr.Row().style(equal_height=False):
... | run(**kwargs) |
class Server(Tab):
def title(self):
return "Server(experimental)"
def sort(self):
return 6
def ui(self, outlet):
def start(host, port):
if multiprocessing.get_start_method() == 'fork':
multiprocessing.set_start_method('spawn', force=True)
p... | modules/tabs/server.py | ddPn08-rvc-webui-c4a12a8 | [
{
"filename": "modules/tabs/merge.py",
"retrieved_chunk": " speaker_id,\n source_audio,\n embedder_name,\n embedding_output_layer,\n transpose,\n fo_curve_file,\n pitch_extraction_algo,\n auto_load_index,\n fa... | python | run(**kwargs) |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | ProofActionGroup(*proof_actions.rewrites).copy()] |
for group in reversed(self.action_groups):
hlayout = QHBoxLayout()
group.init_buttons(self)
for action in group.actions:
assert action.button is not None
hlayout.addWidget(action.button)
hlayout.addStretch()
widget = Q... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/edit_panel.py",
"retrieved_chunk": " self.vertex.clicked.connect(lambda: self._tool_clicked(ToolType.VERTEX))\n self.edge.clicked.connect(lambda: self._tool_clicked(ToolType.EDGE))\n yield ToolbarSection(self.select, self.vertex, self.edge, exclusive=True)\n ... | python | ProofActionGroup(*proof_actions.rewrites).copy()] |
import os
import sys
import torch
from modules.cmd_opts import opts
ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MODELS_DIR = os.path.join(ROOT_DIR, "models")
def has_mps():
if sys.platform != "darwin":
return False
else:
if not getattr(torch, "has_mps", False):
... | precision == "fp16" |
half_support = (
torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 5.3
)
if not half_support:
print("WARNING: FP16 is not supported on this GPU")
is_half = False
device = "cuda:0"
if not torch.cuda.is_available():
if has_mps():
print("Using MPS")
device = "mps"
... | modules/shared.py | ddPn08-rvc-webui-c4a12a8 | [
{
"filename": "launch.py",
"retrieved_chunk": " return False\n return spec is not None\ndef commit_hash():\n global stored_commit_hash\n if stored_commit_hash is not None:\n return stored_commit_hash\n try:\n stored_commit_hash = run(f\"{git} rev-parse HEAD\").strip()\n e... | python | precision == "fp16" |
from __future__ import annotations
import copy
from typing import Iterator, Union, cast
import pyzx
from PySide6.QtCore import QPointF, QPersistentModelIndex, Qt, \
QModelIndex, QItemSelection, QRect, QSize
from PySide6.QtGui import QVector2D, QFont, QColor, QPainter, QPen, QFontMetrics, QIcon
from PySide6.QtWidg... | strong_comp(self.graph, g, w, self.graph_scene) |
cmd = AddRewriteStep(self.graph_view, g, self.step_view, "bialgebra")
self.undo_stack.push(cmd, anim_after=anim)
def _wand_trace_finished(self, trace: WandTrace) -> None:
if self._magic_slice(trace):
return
elif self._magic_identity(trace):
return
... | zxlive/proof_panel.py | Quantomatic-zxlive-c7b5c28 | [
{
"filename": "zxlive/proof_actions.py",
"retrieved_chunk": " g.remove_vertices(rem_verts)\n g.add_edge_table(etab)\n cmd = AddRewriteStep(panel.graph_view, g, panel.step_view, self.name)\n if self.name == operations['spider']['text']:\n anim = anims.fuse(panel.graph_s... | python | strong_comp(self.graph, g, w, self.graph_scene) |
from .Print import FolderTestPressetPrints
from os import listdir
from os.path import isdir,isfile
import os
import shutil
from shutil import rmtree,copytree
from .folder_hash import are_folders_equal
class FolderTestPresetExtras(FolderTestPressetPrints):
def _get_expected_file(self, folder: str):
eleme... | _side_effect_folder is None: |
return
rmtree('side_effect_copy', ignore_errors=True)
copytree(self._side_effect_folder,'side_effect_copy')
def _side_effect_folder_changed(self)->bool:
return not are_folders_equal(self._side_effect_folder,'side_effect_copy')
def _rebase_side_effect_folder(self):
... | Build/CToolKit/FolderTestPreset/Extras.py | OUIsolutions-CWebStudio-633d7c6 | [
{
"filename": "Build/CToolKit/FolderTestPreset/Execution.py",
"retrieved_chunk": "from .folder_hash import are_folders_equal\nclass FolderTestPressetExecution(FolderTestPressetCreation):\n def _execute_test_presset(self,folder:str):\n self._rebase_side_effect_folder()\n execution_file = sel... | python | _side_effect_folder is None: |
import io
import json
import os
import traceback
from typing import *
import soundfile as sf
from flask import Flask, make_response, request, send_file
from scipy.io.wavfile import write
from modules.server.model import VoiceServerModel
model: Optional[VoiceServerModel] = None
app = Flask(__name__)
@app.route('/pin... | tgt_sr, data=out_audio) |
output_buffer.seek(0)
response = make_response(send_file(output_buffer, mimetype="audio/wav"), 200)
return response
else:
return make_response("use post method", 400)
if __name__ == "__main__":
app.run() | server.py | ddPn08-rvc-webui-c4a12a8 | [
{
"filename": "modules/tabs/server.py",
"retrieved_chunk": " def convert(host, port, input_voice_file, speaker_id, transpose, pitch_extraction_algo, retrieval_feature_ratio):\n params = {\n \"speaker_id\": speaker_id,\n \"transpose\": transpose,\n ... | python | tgt_sr, data=out_audio) |
from typing import List
from platform import system as current_os
from os import remove
from .Errors.CopilationError import CopilationError
from .Errors.CopilationWarning import CopilationWarning
from .Errors.ValgrindError import ValgrindError
from .Errors.ValgrindLeak import ValgrindLeak
from .ComandLineExecution... | output, result.status_code) |
if raise_warnings and 'warning:' in result.output:
raise CopilationWarning(result.output)
def compile_project( file: str,compiler ='gcc', output: str = None, flags: List[str] = None, raise_errors: bool = True,
raise_warnings: bool = True)->str:
"""Copiles an project file
Ar... | Build/CToolKit/comand_line_functions.py | OUIsolutions-CWebStudio-633d7c6 | [
{
"filename": "Build/CToolKit/ComandLineExecution.py",
"retrieved_chunk": " self.status_code, self.output = subprocess.getstatusoutput(command)\n if self.status_code != 0:\n raise ExecutionError(self.output, self.status_code)",
"score": 27.430730928235896
},
{
"filename"... | python | output, result.status_code) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.