Datasets:

---

sourcegraph

/

test-dataset-context-aware-fim-autocomplete-oracle-unixcoder_cosine_sim

like 0

Follow

Sourcegraph 20

[ { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " variations.append(self._variation_pipe(\n prompt=prompts[iteration * max_batch_size:\n (iteration + 1) * max_batch_size],\n image=images[iteration * max_batch_size:\n (iteration + 1) * max_batch_size],\n num_inference_steps=self._variation_num_inference_steps,\n strength=variation_degree,\n guidance_scale=self._variation_guidance_scale,\n num_images_per_prompt=1,\n output_type='np').images)", "score": 0.7148727774620056 }, { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " \"\"\"\n if not (0 <= variation_degree <= 1):\n raise ValueError('variation_degree should be between 0 and 1')\n variations = []\n for _ in tqdm(range(num_variations_per_image)):\n sub_variations = self._image_variation(\n images=images,\n prompts=list(additional_info),\n size=size,\n variation_degree=variation_degree)", "score": 0.7111392617225647 }, { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " self._random_sampling_pipe = self._random_sampling_pipe.to(dev())\n self._variation_checkpoint = variation_checkpoint\n self._variation_guidance_scale = variation_guidance_scale\n self._variation_num_inference_steps = variation_num_inference_steps\n self._variation_batch_size = variation_batch_size\n self._variation_pipe = \\\n StableDiffusionImg2ImgPipeline.from_pretrained(\n self._variation_checkpoint,\n torch_dtype=torch.float16)\n self._variation_pipe.safety_checker = None", "score": 0.7059246301651001 }, { "filename": "apis/improved_diffusion_api.py", "retrieved_chunk": " return variations\n def _image_variation(self, images, labels, variation_degree):\n samples, _ = sample(\n sampler=self._sampler,\n start_t=variation_degree,\n start_image=torch.Tensor(images).to(dist_util.dev()),\n labels=(None if not self._class_cond\n else torch.LongTensor(labels).to(dist_util.dev())),\n num_samples=images.shape[0],\n batch_size=self._batch_size,", "score": 0.7021768093109131 }, { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " return np.around(np.clip(image * 255, a_min=0, a_max=255)).astype(np.uint8)\nclass StableDiffusionAPI(API):\n def __init__(self, random_sampling_checkpoint,\n random_sampling_guidance_scale,\n random_sampling_num_inference_steps,\n random_sampling_batch_size,\n variation_checkpoint,\n variation_guidance_scale,\n variation_num_inference_steps,\n variation_batch_size,", "score": 0.6891653537750244 } ]

[ { "filename": "apis/api.py", "retrieved_chunk": " The degree of image variation.\n Returns:\n numpy.ndarray:\n A numpy array of shape [num_samples x num_variations_per_image\n x width x height x channels] containing the generated image\n variations as numpy arrays of type uint8.\n \"\"\"\n pass", "score": 0.9517544507980347 }, { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " format \"widthxheight\". Options include \"256x256\", \"512x512\",\n and \"1024x1024\".\n variation_degree (float):\n The image variation degree, between 0~1. A larger value means\n more variation.\n Returns:\n numpy.ndarray:\n A numpy array of shape [num_samples x num_variations_per_image\n x width x height x channels] containing the generated image\n variations as numpy arrays of type uint8.", "score": 0.9422736167907715 }, { "filename": "apis/api.py", "retrieved_chunk": " def image_variation(self, images, additional_info,\n num_variations_per_image, size, variation_degree=None):\n \"\"\"\n Generates a specified number of variations for each image in the input\n array.\n Args:\n images (numpy.ndarray):\n A numpy array of shape [num_samples x width x height\n x channels] containing the input images as numpy arrays of type\n uint8.", "score": 0.9247487783432007 }, { "filename": "apis/api.py", "retrieved_chunk": " additional_info (numpy.ndarray):\n A numpy array with the first dimension equaling to\n num_samples containing additional information such as labels or\n prompts provided by image_random_sampling.\n num_variations_per_image (int):\n The number of variations to generate for each input image.\n size (str):\n The size of the generated image variations in the\n format \"widthxheight\", e.g., \"1024x1024\".\n variation_degree (int or float, optional):", "score": 0.9074827432632446 }, { "filename": "apis/stable_diffusion_api.py", "retrieved_chunk": " Returns:\n numpy.ndarray:\n A numpy array of shape [num_samples x width x height x\n channels] with type np.uint8 containing the generated image\n samples as numpy arrays.\n numpy.ndarray:\n A numpy array with length num_samples containing prompts for\n each image.\n \"\"\"\n max_batch_size = self._random_sampling_batch_size", "score": 0.9039590954780579 } ]

[ { "filename": "apis/improved_diffusion_api.py", "retrieved_chunk": " all_images.append(sample.detach().cpu().numpy())\n if class_cond:\n all_labels.append(classes.detach().cpu().numpy())\n cnt += sample.shape[0]\n logging.info(f\"Created {cnt} samples\")\n all_images = np.concatenate(all_images, axis=0)\n all_images = all_images[: num_samples]\n if class_cond:\n all_labels = np.concatenate(all_labels, axis=0)\n all_labels = all_labels[: num_samples]", "score": 0.8331754207611084 }, { "filename": "main.py", "retrieved_chunk": " batch_size=args.fid_batch_size)\n logging.info(f'fid={fid}')\n log_fid(args.result_folder, fid, 0)\n for t in range(start_t, len(args.num_samples_schedule)):\n logging.info(f't={t}')\n assert samples.shape[0] % private_num_classes == 0\n num_samples_per_class = samples.shape[0] // private_num_classes\n if args.lookahead_degree == 0:\n packed_samples = np.expand_dims(samples, axis=1)\n else:", "score": 0.763414204120636 }, { "filename": "apis/improved_diffusion_api.py", "retrieved_chunk": " if labels is None:\n classes = torch.randint(\n low=0, high=NUM_CLASSES, size=(current_batch_size,),\n device=dist_util.dev()\n )\n else:\n classes = labels[batch_cnt * batch_size:\n (batch_cnt + 1) * batch_size]\n model_kwargs[\"y\"] = classes\n sample = sampler(", "score": 0.7563799619674683 }, { "filename": "apis/improved_diffusion_api.py", "retrieved_chunk": " batch_cnt = 0\n cnt = 0\n while cnt < num_samples:\n current_batch_size = \\\n (batch_size if start_image is None\n else min(batch_size,\n start_image.shape[0] - batch_cnt * batch_size))\n shape = (current_batch_size, 3, image_size, image_size)\n model_kwargs = {}\n if class_cond:", "score": 0.7471418380737305 }, { "filename": "dpsda/dataset.py", "retrieved_chunk": " for path in self.local_images]\n sorted_classes = {x: i for i, x in enumerate(sorted(set(class_names)))}\n self.local_classes = [sorted_classes[x] for x in class_names]\n def __len__(self):\n return len(self.local_images)\n def __getitem__(self, idx):\n path = self.local_images[idx]\n with bf.BlobFile(path, 'rb') as f:\n pil_image = Image.open(f)\n pil_image.load()", "score": 0.7222076654434204 } ]

[ { "filename": "src/manifests/abstract_manifest.py", "retrieved_chunk": " path: Path | str,\n version: int,\n type_: ManifestType,\n size: int = 0,\n ) -> None:\n AbstractFile.__init__(self, path, type_, size)\n self._version: int = version\n self._files: list[T] | None = None\n @property\n def name(self) -> str:", "score": 0.8008872866630554 }, { "filename": "src/manifests/manifest.py", "retrieved_chunk": " self,\n path: Path | str,\n hash_: str,\n version: int,\n type_: ManifestType,\n size: int = 0,\n ) -> None:\n AbstractManifest.__init__(self, path, version, type_, size)\n AbstractManifestFile.__init__(self, path, hash_, type_, size, version)\n def _read(self) -> list[AssetBundle]:", "score": 0.8001732230186462 }, { "filename": "src/files/bundle_file.py", "retrieved_chunk": " )\n def __init__(\n self, pcr_file: AssetBundle, obj: UnityPy.environment.ObjectReader\n ) -> None:\n self._parent_path: Path = pcr_file.path.parent.parent\n self._object: UnityPy.environment.ObjectReader | None = obj\n self._type: BundleType = BundleType(obj.type.name)\n self._data: Any = None\n self.image: Any = None\n self.script: Any = None", "score": 0.796186089515686 }, { "filename": "src/files/movie_file.py", "retrieved_chunk": "import os\nfrom pathlib import Path\nfrom ..abc import AbstractManifestFile\nfrom ..config import AssetType, Config\nfrom ..protocols import Extractable\nclass MovieFile(AbstractManifestFile, Extractable):\n def __init__(self, path: Path | str, hash_: str, size: int = 0) -> None:\n super().__init__(path, hash_, AssetType.MOVIE, size)\n def extract(self) -> None:\n self.download()", "score": 0.7880679368972778 }, { "filename": "src/cysp2skel.py", "retrieved_chunk": " __slots__ = (\n \"_cysp_dir\",\n \"mdb\",\n \"_current_base\",\n \"_current_base_animation_count\",\n \"_current_animation_count_index\",\n )\n def __init__(self, cysp_dir: str | Path, mdb: MDB) -> None:\n self._cysp_dir = Path(cysp_dir)\n self.mdb = mdb", "score": 0.7879812717437744 } ]

[ { "filename": "src/asset_bundle.py", "retrieved_chunk": " if len(self._name.split(\"_\", 1)) == 2:\n sub_folder, name = self._name.split(\"_\", 1)\n return self._path.parent / sub_folder / \"assetbundle\" / name\n return self._path\n @property\n def url(self):\n endpoint = f\"{AssetType.ASSET.value}/{self._hash[:2]}/{self._hash}\"\n return f\"https://{Config.host.value}/{endpoint}\"\n @property\n def files(self) -> list[BundleFile]:", "score": 0.7757946252822876 }, { "filename": "src/asset_bundle.py", "retrieved_chunk": " size: int,\n ) -> None:\n super().__init__(path, hash_, AssetType.ASSET, size)\n @property\n def name(self) -> str:\n if name := self._name.split(\"_\", 1)[1]:\n return name\n return self._name\n @property\n def path(self) -> Path:", "score": 0.7515809535980225 }, { "filename": "src/abc/abstract_manifest_file.py", "retrieved_chunk": " version: int = 0,\n ) -> None:\n AbstractFile.__init__(self, path, type_, size)\n self._hash = hash_\n self._version = version\n @property\n def url(self) -> str:\n if type(self._type) == ManifestType:\n endpoint = f\"{self._type.value % (self._version,self.name)}\"\n else:", "score": 0.7486279606819153 }, { "filename": "src/dataminer.py", "retrieved_chunk": " ret = manifest.get_files(match)\n return ret\n @staticmethod\n def _pool_bundle_files(data: tuple[AssetBundle, str]) -> list[BundleFile]:\n assetbundle, match = data\n return assetbundle.get_files(match)\n @staticmethod\n def _extract_file(file: Extractable):\n file.extract()\n @staticmethod", "score": 0.7388178110122681 }, { "filename": "src/cysp2skel.py", "retrieved_chunk": " self._current_base: BufferedReader | None = None\n self._current_base_animation_count: int = 0\n self._current_animation_count_index: int = 0\n def _get_base(self, str_id: str) -> RawIOBase:\n files: list[str] = [\n f\"{str_id}_{name}.cysp\"\n for name in [\n \"CHARA_BASE\",\n \"DEAR\",\n \"NO_WEAPON\",", "score": 0.7387941479682922 } ]

[ { "filename": "src/manifests/abstract_manifest.py", "retrieved_chunk": " return self._name\n @property\n def path(self) -> Path:\n return self._path\n @property\n def url(self) -> str:\n endpoint = self._type.value % (str(self._version), self._name)\n return f\"https://{Config.host.value}/{endpoint}\"\n @property\n def version(self) -> int:", "score": 0.8489024639129639 }, { "filename": "src/files/bundle_file.py", "retrieved_chunk": " self.container: str | None = None\n self._asset_name: str | None = None\n # for Protocol\n self._name = self.name\n self._path = self.path\n self._size = self.size\n @property\n def parent_path(self) -> Path:\n return self._parent_path\n @property", "score": 0.8166093826293945 }, { "filename": "src/asset_bundle.py", "retrieved_chunk": " size: int,\n ) -> None:\n super().__init__(path, hash_, AssetType.ASSET, size)\n @property\n def name(self) -> str:\n if name := self._name.split(\"_\", 1)[1]:\n return name\n return self._name\n @property\n def path(self) -> Path:", "score": 0.8102505207061768 }, { "filename": "src/files/bundle_file.py", "retrieved_chunk": " self._asset_name = self.data.name\n if self._asset_name:\n return self._asset_name + self.extention\n else:\n raise Exception(\"Name cannot be None.\")\n @property\n def size(self) -> int:\n return 0\n @property\n def path(self) -> Path:", "score": 0.8080618381500244 }, { "filename": "src/manifests/asset_manifest.py", "retrieved_chunk": "from ..config import ManifestType\nfrom .manifest import AbstractManifest, Manifest\nclass AssetManifest(AbstractManifest[Manifest]):\n def __init__(self, version: int):\n AbstractManifest.__init__(\n self, \"manifest_assetmanifest\", version, ManifestType.ASSET\n )\n def _read(self) -> list[Manifest]:\n self.download()\n with self.path.open() as f:", "score": 0.807807207107544 } ]

[ { "filename": "src/manifests/abstract_manifest.py", "retrieved_chunk": " path: Path | str,\n version: int,\n type_: ManifestType,\n size: int = 0,\n ) -> None:\n AbstractFile.__init__(self, path, type_, size)\n self._version: int = version\n self._files: list[T] | None = None\n @property\n def name(self) -> str:", "score": 0.9279099702835083 }, { "filename": "src/manifests/manifest.py", "retrieved_chunk": " self,\n path: Path | str,\n hash_: str,\n version: int,\n type_: ManifestType,\n size: int = 0,\n ) -> None:\n AbstractManifest.__init__(self, path, version, type_, size)\n AbstractManifestFile.__init__(self, path, hash_, type_, size, version)\n def _read(self) -> list[AssetBundle]:", "score": 0.9129337072372437 }, { "filename": "src/abc/abstract_file.py", "retrieved_chunk": " type_: T,\n size: int = 0,\n ) -> None:\n self._path: Path = Path(path)\n self._name: str = self._path.name\n self._type: T = type_\n self._size: int = size\n @property\n def path(self) -> Path:\n return self._path", "score": 0.8923449516296387 }, { "filename": "src/asset_bundle.py", "retrieved_chunk": " size: int,\n ) -> None:\n super().__init__(path, hash_, AssetType.ASSET, size)\n @property\n def name(self) -> str:\n if name := self._name.split(\"_\", 1)[1]:\n return name\n return self._name\n @property\n def path(self) -> Path:", "score": 0.8744111061096191 }, { "filename": "src/files/bundle_file.py", "retrieved_chunk": " self._asset_name = self.data.name\n if self._asset_name:\n return self._asset_name + self.extention\n else:\n raise Exception(\"Name cannot be None.\")\n @property\n def size(self) -> int:\n return 0\n @property\n def path(self) -> Path:", "score": 0.8651881217956543 } ]

[ { "filename": "src/files/file_container.py", "retrieved_chunk": " def get_files(self, match: str) -> list[T]:\n files: list[T] = []\n for file in self.files:\n if re.search(match, file.name):\n files.append(file)\n return files", "score": 0.7731958627700806 }, { "filename": "src/files/file_container.py", "retrieved_chunk": " @property\n def files(self) -> list[T]:\n if self._files is None:\n self._files = self._read()\n return self._files\n def get_file(self, match: str) -> T | None:\n for file in self.files:\n if re.search(match, file.name):\n return file\n return None", "score": 0.7544993162155151 }, { "filename": "src/manifests/asset_manifest.py", "retrieved_chunk": "from ..config import ManifestType\nfrom .manifest import AbstractManifest, Manifest\nclass AssetManifest(AbstractManifest[Manifest]):\n def __init__(self, version: int):\n AbstractManifest.__init__(\n self, \"manifest_assetmanifest\", version, ManifestType.ASSET\n )\n def _read(self) -> list[Manifest]:\n self.download()\n with self.path.open() as f:", "score": 0.7522104978561401 }, { "filename": "src/manifests/asset_manifest.py", "retrieved_chunk": " rows = f.readlines()\n files = []\n for row in rows:\n path, hash_, _, size, *_ = row.split(\",\")\n manifest = Manifest(\n path, hash_, self.version, ManifestType.ASSET, int(size)\n )\n files.append(manifest)\n return files", "score": 0.7503558993339539 }, { "filename": "src/manifests/__init__.py", "retrieved_chunk": "from .asset_manifest import AssetManifest\nfrom .manifest import Manifest\nfrom .movie_manifest import MovieManifest\nfrom .sound_manifest import SoundManifest\n__all__ = [\n \"AssetManifest\",\n \"Manifest\",\n \"MovieManifest\",\n \"SoundManifest\",\n]", "score": 0.7439733147621155 } ]

[ { "filename": "llm_oracle/markets/kalshi.py", "retrieved_chunk": " def get_end_date(self) -> datetime.datetime:\n return dateparser.parse(self.resp_json[\"close_time\"])\n def get_market_probability(self) -> float:\n return self.resp_json[\"last_price\"] / 100\n def get_universal_id(self) -> str:\n return \"kalshi2:\" + self.resp_json[\"ticker\"]\n def is_active(self) -> bool:\n return self.resp_json[\"status\"] == \"active\"\n def get_market_result(self) -> Optional[float]:\n result = self.resp_json.get(\"result\")", "score": 0.8675434589385986 }, { "filename": "llm_oracle/markets/manifold.py", "retrieved_chunk": " text.append(text_utils.world_state_to_string())\n text.append(f\"description: \\n```\\n{self.get_description().strip()[:2000]}\\n```\")\n return \"\\n\".join(text)\n def get_description(self) -> str:\n if self.event_market.description is None:\n return \"\"\n return _content_to_text(self.event_market.description)\n def get_title(self) -> str:\n return self.event_market.question\n def get_end_date(self) -> datetime.datetime:", "score": 0.8381267786026001 }, { "filename": "llm_oracle/markets/manifold.py", "retrieved_chunk": " return datetime.datetime.fromtimestamp(self.event_market.closeTime / 1000)\n def get_market_probability(self) -> float:\n return self.event_market.probability\n def get_universal_id(self) -> str:\n return \"manifold2:\" + self.event_market.id\n def is_active(self) -> bool:\n return not self.event_market.isResolved\n def get_market_result(self) -> Optional[float]:\n res_p = self.event_market.resolutionProbability\n return None if res_p is None else float(res_p)", "score": 0.8327733874320984 }, { "filename": "llm_oracle/markets/base.py", "retrieved_chunk": " @abstractmethod\n def get_market_probability(self) -> float:\n return\n @abstractmethod\n def get_market_result(self) -> Optional[float]:\n return\n @abstractmethod\n def get_title(self) -> str:\n return\n @abstractmethod", "score": 0.8105581998825073 }, { "filename": "llm_oracle/markets/kalshi.py", "retrieved_chunk": " self.resp_json = resp_json\n def to_text(self, *args, **kwargs) -> str:\n text = [\"Kalshi Market\"]\n for key in [\"title\", \"category\", \"subtitle\", \"can_close_early\"]:\n text.append(f\"{key}: {self.resp_json[key]}\")\n text.append(f\"close_date: {text_utils.future_date_to_string(self.get_end_date())}\")\n text.append(text_utils.world_state_to_string())\n return \"\\n\".join(text)\n def get_title(self) -> str:\n return self.resp_json[\"title\"]", "score": 0.7611924409866333 } ]

[ { "filename": "cdm_processing/abstract_cdm_processor.py", "retrieved_chunk": " self._output_path = output_path\n self._profile = False\n self._configure_logger()\n def set_profile(self, profile: bool):\n self._profile = profile\n def get_profile(self):\n return self._profile\n def _configure_logger(self):\n create_logger(os.path.join(self._output_path, LOGGER_FILE_NAME))\n @abstractmethod", "score": 0.874997079372406 }, { "filename": "utils/logger.py", "retrieved_chunk": " log_file_name: The name of the file where the log will be written to.\n \"\"\"\n logger = logging.getLogger()\n logger.setLevel(logging.DEBUG)\n if not len(logger.handlers):\n _add_file_handler(logger=logger, log_file_name=log_file_name)\n _add_stream_handler(logger=logger)\n sys.excepthook = handle_exception\nclass _ConfigLogger(object):\n def log_config(self, config):", "score": 0.7554537653923035 }, { "filename": "cdm_processing/cehr_bert_cdm_processor.py", "retrieved_chunk": " map_drugs_to_ingredients=config[\"mapping\"].getboolean(\"map_drugs_to_ingredients\"),\n concepts_to_remove=[int(x) for x in config[\"mapping\"].get(\"concepts_to_remove\").split(\",\")],\n )\n # Log config after initializing cdm_data_processor so logger is initialized:\n logger.log_config(config)\n if config[\"debug\"].getboolean(\"profile\"):\n cdm_data_processor.set_profile(True)\n cdm_data_processor.process_cdm_data()\nif __name__ == \"__main__\":\n if len(sys.argv) != 2:", "score": 0.7355486154556274 }, { "filename": "utils/logger.py", "retrieved_chunk": " logging.info(\"Config:\")\n config.write(self)\n def write(self, data):\n line = data.strip()\n logging.info(line)\ndef log_config(config):\n config_logger = _ConfigLogger()\n config_logger.log_config(config)\ndef handle_exception(exc_type, exc_value, exc_traceback):\n if not issubclass(exc_type, KeyboardInterrupt):", "score": 0.7271993160247803 }, { "filename": "data_generating/tokenizer.py", "retrieved_chunk": " def get_mask_token_id(self):\n return self._mask_token_index\n def get_out_of_vocabulary_token_id(self):\n return self._oov_token_index\n def get_first_token_id(self):\n return 4\n def get_last_token_id(self):\n return self.get_vocab_size() - 1\n def save_to_json(self, file_name: str):\n with open(file_name, \"w\") as f:", "score": 0.7125686407089233 } ]

[ { "filename": "simulating/simulator.py", "retrieved_chunk": " self._configure_logger()\n if settings is None:\n self._init_from_json(json_file_name)\n else:\n self._init_from_settings(settings)\n self.save_to_json(os.path.join(self._root_folder, JSON_FILE_NAME))\n def _init_from_json(self, json_file_name: str):\n logging.info(\"Loading simulation configuration from %s\", json_file_name)\n with open(json_file_name, \"r\") as f:\n loaded = json.load(f)", "score": 0.7839441299438477 }, { "filename": "tests/test_data_generating.py", "retrieved_chunk": " json_filename = os.path.join(self.parquet_folder, \"_test.json\")\n concept_tokenizer.save_to_json(json_filename)\n concept_tokenizer_2 = tokenizer.load_from_json(json_filename)\n os.remove(json_filename)\n encoding_2 = concept_tokenizer_2.encode(test_concept_ids)\n assert encoding == encoding_2\n def test_data_generator(self):\n learning_objectives = [learning_objective.MaskedLanguageModelLearningObjective(work_folder=self.parquet_folder),\n learning_objective.VisitPredictionLearningObjective(work_folder=self.parquet_folder)]\n bert_data_generator = data_generator.DataGenerator(training_data_path=self.parquet_folder,", "score": 0.7758247256278992 }, { "filename": "cdm_processing/cehr_bert_cdm_processor.py", "retrieved_chunk": " logging.debug(\"Partition %s existing visits: %s\", partition_i, mapping_stats[\"existing_visits\"])\n logging.debug(\"Partition %s newly created visits: %s\", partition_i, mapping_stats[\"new_visits\"])\ndef main(args: List[str]):\n config = configparser.ConfigParser()\n with open(args[0]) as file: # Explicitly opening file so error is thrown when not found\n config.read_file(file)\n cdm_data_processor = CehrBertCdmDataProcessor(\n cdm_data_path=config[\"system\"].get(\"cdm_data_path\"),\n max_cores=config[\"system\"].getint(\"max_cores\"),\n output_path=config[\"system\"].get(\"output_path\"),", "score": 0.7379725575447083 }, { "filename": "tests/test_data_generating.py", "retrieved_chunk": " break\n assert batch_count == 1\n def test_dataset_from_generator(self):\n learning_objectives = [learning_objective.MaskedLanguageModelLearningObjective(work_folder=self.parquet_folder),\n learning_objective.VisitPredictionLearningObjective(work_folder=self.parquet_folder)]\n bert_data_generator = data_generator.DataGenerator(training_data_path=self.parquet_folder,\n batch_size=4,\n max_sequence_length=10,\n min_sequence_length=5,\n is_training=True,", "score": 0.7360270619392395 }, { "filename": "data_generating/data_generator.py", "retrieved_chunk": " sampled and tokens will be masked.\n learning_objectives: One or more learning objectives for which to generate data.\n \"\"\"\n self._parquet_path = training_data_path\n self._batch_size = batch_size\n self._max_sequence_length = max_sequence_length\n self._min_sequence_length = min_sequence_length\n self._is_training = is_training\n self._parquet_data_iterator = ParquetDataIterator(training_data_path)\n self._nrows = len(self._parquet_data_iterator)", "score": 0.7303421497344971 } ]

[ { "filename": "simulating/cdm_data.py", "retrieved_chunk": " self._person_day_of_birth.append(day_of_birth)\n self._person_gender_concept_id.append(gender_concept_id)\n def add_visit_occurrence(self, person_id: int, visit_occurrence_id: int, visit_start_date: np.datetime64,\n visit_end_date: np.datetime64, visit_concept_id: int):\n self._visit_occurrence_person_id.append(person_id)\n self._visit_occurrence_visit_occurrence_id.append(visit_occurrence_id)\n self._visit_occurrence_visit_start_date.append(visit_start_date)\n self._visit_occurrence_visit_end_date.append(visit_end_date)\n self._visit_occurrence_visit_concept_id.append(visit_concept_id)\n def add_condition_occurrence(self, person_id: int, visit_occurrence_id: int, condition_start_date: np.datetime64,", "score": 0.8277826309204102 }, { "filename": "simulating/cdm_data.py", "retrieved_chunk": " logging.debug(\"Partition %s persons: %s\", partition_i, len(self._person_person_id))\n logging.debug(\"Partition %s visit_occurrences: %s\", partition_i, len(self._visit_occurrence_person_id))\n total_days = np.sum(np.subtract(self._observation_period_observation_period_end_date.collect(),\n self._observation_period_observation_period_start_date.collect()).view(\n np.int64))\n logging.debug(\"Partition %s mean days between visits: %.1f\", partition_i,\n total_days / len(self._visit_occurrence_person_id))\n logging.debug(\"Partition %s mean concepts per visit: %.1f\", partition_i,\n len(self._condition_occurrence_person_id) / len(self._visit_occurrence_person_id))\n logging.debug(\"Partition %s unique concept count: %s\", partition_i,", "score": 0.8027909398078918 }, { "filename": "tests/test_cdm_processor_utils.py", "retrieved_chunk": " ]\n )\n )\n self.cdm_tables = {\"person\": person,\n \"observation_period\": observation_period,\n \"visit_occurrence\": visit_occurrence,\n \"condition_occurrence\": condition_occurrence,\n \"death\": death}\n def test_union_domain_tables(self):\n event_table = cdm_utils.union_domain_tables(self.cdm_tables)", "score": 0.7994869947433472 }, { "filename": "simulating/cdm_data.py", "retrieved_chunk": " visit_occurrence = pa.Table.from_arrays(arrays=[\n self._visit_occurrence_person_id.collect(),\n self._visit_occurrence_visit_occurrence_id.collect(),\n self._visit_occurrence_visit_start_date.collect(),\n self._visit_occurrence_visit_end_date.collect(),\n self._visit_occurrence_visit_concept_id.collect()],\n names=[\"person_id\", \"visit_occurrence_id\", \"visit_start_date\", \"visit_end_date\", \"visit_concept_id\"])\n condition_occurrence = pa.Table.from_arrays(arrays=[\n self._condition_occurrence_person_id.collect(),\n self._condition_occurrence_visit_occurrence_id.collect(),", "score": 0.7974027395248413 }, { "filename": "tests/test_cdm_processor_utils.py", "retrieved_chunk": " assert len(visit_group) == 1\n assert visit_group[\"concept_id\"].to_pylist()[0] == 123\n # Second visit in CDM data, linked by date\n visit_group = event_table.filter(pc.equal(event_table[\"internal_visit_id\"], 1))\n assert len(visit_group) == 1\n assert visit_group[\"concept_id\"].to_pylist()[0] == 456\n # Third visit in CDM data, has no events:\n visit_group = event_table.filter(pc.equal(event_table[\"internal_visit_id\"], 2))\n assert len(visit_group) == 0\n # New visit, derived from condition occurrence", "score": 0.7924344539642334 } ]

[ { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.7954727411270142 }, { "filename": "examples/basic_leverage_adjustment.py", "retrieved_chunk": " print(exchange.update_leverage(21, \"ETH\", False))\n # Add 1 dollar of extra margin to the ETH position\n print(exchange.update_isolated_margin(1, \"ETH\"))\n # Get the user state and print out the final leverage information after our changes\n user_state = info.user_state(account.address)\n print(\"Current leverage for ETH:\")\n print(json.dumps(user_state[\"assetPositions\"][exchange.coin_to_asset[\"ETH\"]][\"position\"][\"leverage\"], indent=2))\nif __name__ == \"__main__\":\n main()", "score": 0.7746478319168091 }, { "filename": "examples/basic_leverage_adjustment.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n # Get the user state and print out leverage information for ETH\n user_state = info.user_state(account.address)\n print(\"Current leverage for ETH:\")\n print(json.dumps(user_state[\"assetPositions\"][exchange.coin_to_asset[\"ETH\"]][\"position\"][\"leverage\"], indent=2))\n # Set the ETH leverage to 21x (cross margin)\n print(exchange.update_leverage(21, \"ETH\"))\n # Set the ETH leverage to 22x (isolated margin)", "score": 0.7610678672790527 }, { "filename": "tests/signing_test.py", "retrieved_chunk": " order_spec_preprocessing,\n sign_l1_action,\n sign_usd_transfer_action,\n)\ndef test_phantom_agent_creation_matches_production():\n timestamp = 1677777606040\n order_spec: OrderSpec = {\n \"order\": {\n \"asset\": 4,\n \"isBuy\": True,", "score": 0.7588846683502197 }, { "filename": "examples/cancel_open_orders.py", "retrieved_chunk": " info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n open_orders = info.open_orders(account.address)\n for open_order in open_orders:\n print(f\"cancelling order {open_order}\")\n exchange.cancel(open_order[\"coin\"], open_order[\"oid\"])\nif __name__ == \"__main__\":\n main()", "score": 0.7582072019577026 } ]

[ { "filename": "engine_for_finetuning.py", "retrieved_chunk": " loss, output = train_class_batch(model, samples, targets,\n criterion)\n else:\n with torch.cuda.amp.autocast(dtype=torch.bfloat16):\n loss, output = train_class_batch(model, samples, targets,\n criterion)\n loss_value = loss.item()\n if not math.isfinite(loss_value):\n print(\"Loss is {}, stopping training\".format(loss_value))\n sys.exit(1)", "score": 0.8779315948486328 }, { "filename": "engine_for_finetuning.py", "retrieved_chunk": " if loss_scaler is None:\n loss /= update_freq\n model.backward(loss)\n grad_norm = model.get_global_grad_norm()\n model.step()\n if (data_iter_step + 1) % update_freq == 0:\n # Deepspeed will call step() & model.zero_grad() automatic\n if model_ema is not None:\n model_ema.update(model)\n loss_scale_value = get_loss_scale_for_deepspeed(model)", "score": 0.8648980855941772 }, { "filename": "engine_for_finetuning.py", "retrieved_chunk": " create_graph=is_second_order,\n update_grad=(data_iter_step + 1) % update_freq == 0)\n if (data_iter_step + 1) % update_freq == 0:\n optimizer.zero_grad()\n if model_ema is not None:\n model_ema.update(model)\n loss_scale_value = loss_scaler.state_dict()[\"scale\"]\n torch.cuda.synchronize()\n if mixup_fn is None:\n class_acc = (output.max(-1)[-1] == targets).float().mean()", "score": 0.8445411920547485 }, { "filename": "utils.py", "retrieved_chunk": " self._scaler.unscale_(\n optimizer\n ) # unscale the gradients of optimizer's assigned params in-place\n norm = torch.nn.utils.clip_grad_norm_(parameters, clip_grad)\n else:\n self._scaler.unscale_(optimizer)\n norm = get_grad_norm_(parameters)\n self._scaler.step(optimizer)\n self._scaler.update()\n else:", "score": 0.8222304582595825 }, { "filename": "engine_for_finetuning.py", "retrieved_chunk": " else:\n # this attribute is added by timm on one optimizer (adahessian)\n is_second_order = hasattr(\n optimizer, 'is_second_order') and optimizer.is_second_order\n loss /= update_freq\n grad_norm = loss_scaler(\n loss,\n optimizer,\n clip_grad=max_norm,\n parameters=model.parameters(),", "score": 0.8221230506896973 } ]

[ { "filename": "tests/signing_test.py", "retrieved_chunk": " )\n assert to_hex(phantom_agent[\"connectionId\"]) == \"0xd16723c8d7aab4b768e2060b763165f256825690ed246e6788264b27f6c929b9\"\ndef test_l1_action_signing_matches():\n wallet = eth_account.Account.from_key(\"0x0123456789012345678901234567890123456789012345678901234567890123\")\n signature = sign_l1_action(wallet, [\"uint64\"], [float_to_int_for_hashing(1000)], None, 0)\n assert signature[\"r\"] == \"0xfd19b1e1f8ff9c4b8bd95f3522dee21783e02e381ba34624796d4f579a9fff74\"\n assert signature[\"s\"] == \"0x671f4cd60fa998ef5f1a841ca97dc47ad390915c230745cd3c371b0ef07a723b\"\n assert signature[\"v\"] == 27\ndef test_l1_action_signing_order_matches():\n wallet = eth_account.Account.from_key(\"0x0123456789012345678901234567890123456789012345678901234567890123\")", "score": 0.7856422066688538 }, { "filename": "tests/signing_test.py", "retrieved_chunk": "def test_sign_usd_transfer_action():\n wallet = eth_account.Account.from_key(\"0x0123456789012345678901234567890123456789012345678901234567890123\")\n message = {\n \"destination\": \"0x5e9ee1089755c3435139848e47e6635505d5a13a\",\n \"amount\": \"1\",\n \"time\": 1687816341423,\n }\n signature = sign_usd_transfer_action(wallet, message, False)\n assert signature[\"r\"] == \"0x784b36718fa34328e9875712c3aae5c599e0ed07f2cf59add3102cfba1dc634e\"\n assert signature[\"s\"] == \"0x1cf2ee3b0bc7dd0d7f3236e9c8923ef17bcfbfd524deda4c9427361f1a77af67\"", "score": 0.7811416983604431 }, { "filename": "tests/signing_test.py", "retrieved_chunk": " assert signature[\"s\"] == \"0x235a525be1a3b3c5186a241763a47f4e1db463dbba64a3c4abad3696852cd6ff\"\n assert signature[\"v\"] == 27\ndef test_l1_action_signing_matches_with_vault():\n wallet = eth_account.Account.from_key(\"0x0123456789012345678901234567890123456789012345678901234567890123\")\n signature = sign_l1_action(\n wallet, [\"uint64\"], [float_to_int_for_hashing(1000)], \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\", 0\n )\n assert signature[\"r\"] == \"0x9358ee731732877d9a6d1a761fb6db43f93cb7c69ca74ecb382bd0773ac9b093\"\n assert signature[\"s\"] == \"0x2879b3d8384b80664346c4286c34f947fc970c3a84c2f3995555f68493adf60b\"\n assert signature[\"v\"] == 27", "score": 0.7630033493041992 }, { "filename": "tests/signing_test.py", "retrieved_chunk": " timestamp = 0\n grouping: Literal[\"na\"] = \"na\"\n signature = sign_l1_action(\n wallet,\n [\"(uint32,bool,uint64,uint64,bool,uint8,uint64)[]\", \"uint8\"],\n [[order_spec_preprocessing(order_spec)], order_grouping_to_number(grouping)],\n ZERO_ADDRESS,\n timestamp,\n )\n assert signature[\"r\"] == \"0xc7249fd2e6483b2ab8fb0a80ac5201c4d36c8ed52bea5896012de499cdb78f4f\"", "score": 0.7416164875030518 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.7365168333053589 } ]

[ { "filename": "hyperliquid/exchange.py", "retrieved_chunk": " return self.post(\"/exchange\", payload)\n def order(\n self, coin: str, is_buy: bool, sz: float, limit_px: float, order_type: OrderType, reduce_only: bool = False\n ) -> Any:\n return self.bulk_orders(\n [\n {\n \"coin\": coin,\n \"is_buy\": is_buy,\n \"sz\": sz,", "score": 0.7949283123016357 }, { "filename": "hyperliquid/exchange.py", "retrieved_chunk": " [asset, True, amount],\n ZERO_ADDRESS if self.vault_address is None else self.vault_address,\n timestamp,\n )\n return self._post_action(\n {\n \"type\": \"updateIsolatedMargin\",\n \"asset\": asset,\n \"isBuy\": True,\n \"ntli\": amount,", "score": 0.7946547865867615 }, { "filename": "tests/signing_test.py", "retrieved_chunk": " order_spec: OrderSpec = {\n \"order\": {\n \"asset\": 1,\n \"isBuy\": True,\n \"reduceOnly\": False,\n \"limitPx\": 100,\n \"sz\": 100,\n },\n \"orderType\": {\"limit\": {\"tif\": \"Gtc\"}},\n }", "score": 0.7859667539596558 }, { "filename": "hyperliquid/exchange.py", "retrieved_chunk": " },\n signature,\n timestamp,\n )\n def usd_tranfer(self, amount: float, destination: str) -> Any:\n timestamp = get_timestamp_ms()\n payload = {\n \"destination\": destination,\n \"amount\": str(amount),\n \"time\": timestamp,", "score": 0.7819527387619019 }, { "filename": "examples/basic_adding.py", "retrieved_chunk": "ALLOWABLE_DEVIATION = 0.5\n# The maximum absolute position value the strategy can accumulate in units of the coin.\n# i.e. the strategy will place orders such that it can long up to 1 ETH or short up to 1 ETH\nMAX_POSITION = 1.0\n# The coin to add liquidity on\nCOIN = \"ETH\"\nInFlightOrder = TypedDict(\"InFlightOrder\", {\"type\": Literal[\"in_flight_order\"], \"time\": int})\nResting = TypedDict(\"Resting\", {\"type\": Literal[\"resting\"], \"px\": float, \"oid\": int})\nCancelled = TypedDict(\"Cancelled\", {\"type\": Literal[\"cancelled\"]})\nProvideState = Union[InFlightOrder, Resting, Cancelled]", "score": 0.7528934478759766 } ]

[ { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.7477131485939026 }, { "filename": "examples/basic_transfer.py", "retrieved_chunk": " exchange = Exchange(account, constants.TESTNET_API_URL)\n transfer_result = exchange.usd_tranfer(1, \"0x0000000000000000000000000000000000000000\")\n print(transfer_result)\nif __name__ == \"__main__\":\n main()", "score": 0.7337113618850708 }, { "filename": "tests/signing_test.py", "retrieved_chunk": " order_spec_preprocessing,\n sign_l1_action,\n sign_usd_transfer_action,\n)\ndef test_phantom_agent_creation_matches_production():\n timestamp = 1677777606040\n order_spec: OrderSpec = {\n \"order\": {\n \"asset\": 4,\n \"isBuy\": True,", "score": 0.7257828712463379 }, { "filename": "examples/basic_leverage_adjustment.py", "retrieved_chunk": " print(exchange.update_leverage(21, \"ETH\", False))\n # Add 1 dollar of extra margin to the ETH position\n print(exchange.update_isolated_margin(1, \"ETH\"))\n # Get the user state and print out the final leverage information after our changes\n user_state = info.user_state(account.address)\n print(\"Current leverage for ETH:\")\n print(json.dumps(user_state[\"assetPositions\"][exchange.coin_to_asset[\"ETH\"]][\"position\"][\"leverage\"], indent=2))\nif __name__ == \"__main__\":\n main()", "score": 0.7257300615310669 }, { "filename": "examples/cancel_open_orders.py", "retrieved_chunk": " info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n open_orders = info.open_orders(account.address)\n for open_order in open_orders:\n print(f\"cancelling order {open_order}\")\n exchange.cancel(open_order[\"coin\"], open_order[\"oid\"])\nif __name__ == \"__main__\":\n main()", "score": 0.7216721773147583 } ]

[ { "filename": "examples/basic_adding.py", "retrieved_chunk": " continue\n px = float(f\"{ideal_price:.5g}\") # prices should have at most 5 significant digits\n print(f\"placing order sz:{sz} px:{px} side:{side}\")\n self.provide_state[side] = {\"type\": \"in_flight_order\", \"time\": get_timestamp_ms()}\n response = self.exchange.order(COIN, side == \"B\", sz, px, {\"limit\": {\"tif\": \"Alo\"}})\n print(\"placed order\", response)\n if response[\"status\"] == \"ok\":\n status = response[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n self.provide_state[side] = {\"type\": \"resting\", \"px\": px, \"oid\": status[\"resting\"][\"oid\"]}", "score": 0.7560744881629944 }, { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.741386353969574 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.7289233207702637 }, { "filename": "hyperliquid/websocket_manager.py", "retrieved_chunk": " return f'l2Book:{ws_msg[\"data\"][\"coin\"].lower()}'\n elif ws_msg[\"channel\"] == \"trades\":\n trades = ws_msg[\"data\"]\n if len(trades) == 0:\n return None\n else:\n return f'trades:{trades[0][\"coin\"].lower()}'\n elif ws_msg[\"channel\"] == \"user\":\n return \"userEvents\"\nclass WebsocketManager(threading.Thread):", "score": 0.7231020927429199 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])\n if len(positions) > 0:\n print(\"positions:\")", "score": 0.7198718786239624 } ]

[ { "filename": "examples/basic_agent.py", "retrieved_chunk": "import eth_account\nimport utils\nfrom eth_account.signers.local import LocalAccount\nfrom hyperliquid.exchange import Exchange\nfrom hyperliquid.utils import constants\ndef main():\n config = utils.get_config()\n account: LocalAccount = eth_account.Account.from_key(config[\"secret_key\"])\n print(\"Running with account address:\", account.address)\n exchange = Exchange(account, constants.TESTNET_API_URL)", "score": 0.8402383327484131 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])\n if len(positions) > 0:\n print(\"positions:\")", "score": 0.829068660736084 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.8188760876655579 }, { "filename": "examples/cancel_open_orders.py", "retrieved_chunk": " info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n open_orders = info.open_orders(account.address)\n for open_order in open_orders:\n print(f\"cancelling order {open_order}\")\n exchange.cancel(open_order[\"coin\"], open_order[\"oid\"])\nif __name__ == \"__main__\":\n main()", "score": 0.8009255528450012 }, { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.7985765933990479 } ]

[ { "filename": "examples/basic_adding.py", "retrieved_chunk": " oid: timestamp\n for (oid, timestamp) in self.recently_cancelled_oid_to_time.items()\n if current_time - timestamp > 30000\n }\n user_state = self.info.user_state(self.exchange.wallet.address)\n for position in user_state[\"assetPositions\"]:\n if position[\"position\"][\"coin\"] == COIN:\n self.position = float(position[\"position\"][\"szi\"])\n print(f\"set position to {self.position}\")\n break", "score": 0.7531132698059082 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])\n if len(positions) > 0:\n print(\"positions:\")", "score": 0.752997875213623 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.7466335296630859 }, { "filename": "tests/info_test.py", "retrieved_chunk": " else:\n response = info.funding_history(coin=\"BTC\", startTime=1681923833000, endTime=endTime)\n assert len(response) != 0\n assert response[0][\"coin\"] == \"BTC\"\n for key in [\"coin\", \"fundingRate\", \"premium\", \"time\"]:\n assert key in response[0].keys()\n@pytest.mark.vcr()\ndef test_get_l2_snapshot():\n info = Info(skip_ws=True)\n response = info.l2_snapshot(coin=\"DYDX\")", "score": 0.7444945573806763 }, { "filename": "hyperliquid/exchange.py", "retrieved_chunk": " signature,\n timestamp,\n )\n def update_isolated_margin(self, amount: float, coin: str) -> Any:\n timestamp = get_timestamp_ms()\n asset = self.coin_to_asset[coin]\n amount = float_to_usd_int(amount)\n signature = sign_l1_action(\n self.wallet,\n [\"uint32\", \"bool\", \"int64\"],", "score": 0.7395495176315308 } ]

[ { "filename": "examples/basic_vault.py", "retrieved_chunk": " if len(positions) > 0:\n print(\"positions:\")\n for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL, vault_address=vault)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)", "score": 0.8356189727783203 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":", "score": 0.8337998390197754 }, { "filename": "hyperliquid/exchange.py", "retrieved_chunk": " return self.post(\"/exchange\", payload)\n def order(\n self, coin: str, is_buy: bool, sz: float, limit_px: float, order_type: OrderType, reduce_only: bool = False\n ) -> Any:\n return self.bulk_orders(\n [\n {\n \"coin\": coin,\n \"is_buy\": is_buy,\n \"sz\": sz,", "score": 0.8078904151916504 }, { "filename": "hyperliquid/info.py", "retrieved_chunk": " oid: int,\n side: \"A\" | \"B\",\n sz: float string,\n timestamp: int\n }\n ]\n \"\"\"\n return self.post(\"/info\", {\"type\": \"openOrders\", \"user\": address})\n def all_mids(self) -> Any:\n \"\"\"Retrieve all mids for all actively traded coins.", "score": 0.7915956377983093 }, { "filename": "examples/basic_adding.py", "retrieved_chunk": " f.write(\"\\n\")\n # Set the position to None so that we don't place more orders without knowing our position\n # You might want to also update provide_state to account for the fill. This could help avoid sending an\n # unneeded cancel or failing to send a new order to replace the filled order, but we skipped this logic\n # to make the example simpler\n self.position = None\n def poll(self):\n while True:\n open_orders = self.info.open_orders(self.exchange.wallet.address)\n print(\"open_orders\", open_orders)", "score": 0.7893251776695251 } ]

[ { "filename": "examples/basic_order.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])\n if len(positions) > 0:\n print(\"positions:\")", "score": 0.8374344110488892 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.8100417256355286 }, { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.7971200346946716 }, { "filename": "examples/cancel_open_orders.py", "retrieved_chunk": " info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n open_orders = info.open_orders(account.address)\n for open_order in open_orders:\n print(f\"cancelling order {open_order}\")\n exchange.cancel(open_order[\"coin\"], open_order[\"oid\"])\nif __name__ == \"__main__\":\n main()", "score": 0.7967253923416138 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " if len(positions) > 0:\n print(\"positions:\")\n for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL, vault_address=vault)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)", "score": 0.7904915809631348 } ]

[ { "filename": "examples/basic_agent.py", "retrieved_chunk": " print(\"Running with agent address:\", account.address)\n exchange = Exchange(agent_account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 1000, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)", "score": 0.9622069597244263 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Cancel the order\n if order_result[\"status\"] == \"ok\":\n status = order_result[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n cancel_result = exchange.cancel(\"ETH\", status[\"resting\"][\"oid\"])\n print(cancel_result)\nif __name__ == \"__main__\":\n main()", "score": 0.8943847417831421 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":", "score": 0.885709822177887 }, { "filename": "examples/basic_adding.py", "retrieved_chunk": " continue\n px = float(f\"{ideal_price:.5g}\") # prices should have at most 5 significant digits\n print(f\"placing order sz:{sz} px:{px} side:{side}\")\n self.provide_state[side] = {\"type\": \"in_flight_order\", \"time\": get_timestamp_ms()}\n response = self.exchange.order(COIN, side == \"B\", sz, px, {\"limit\": {\"tif\": \"Alo\"}})\n print(\"placed order\", response)\n if response[\"status\"] == \"ok\":\n status = response[\"response\"][\"data\"][\"statuses\"][0]\n if \"resting\" in status:\n self.provide_state[side] = {\"type\": \"resting\", \"px\": px, \"oid\": status[\"resting\"][\"oid\"]}", "score": 0.877316951751709 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " if len(positions) > 0:\n print(\"positions:\")\n for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL, vault_address=vault)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)", "score": 0.8245100975036621 } ]

[ { "filename": "examples/basic_adding.py", "retrieved_chunk": " f.write(\"\\n\")\n # Set the position to None so that we don't place more orders without knowing our position\n # You might want to also update provide_state to account for the fill. This could help avoid sending an\n # unneeded cancel or failing to send a new order to replace the filled order, but we skipped this logic\n # to make the example simpler\n self.position = None\n def poll(self):\n while True:\n open_orders = self.info.open_orders(self.exchange.wallet.address)\n print(\"open_orders\", open_orders)", "score": 0.8514070510864258 }, { "filename": "hyperliquid/info.py", "retrieved_chunk": " def open_orders(self, address: str) -> Any:\n \"\"\"Retrieve a user's open orders.\n POST /info\n Args:\n address (str): Onchain address in 42-character hexadecimal format;\n e.g. 0x0000000000000000000000000000000000000000.\n Returns: [\n {\n coin: str,\n limitPx: float string,", "score": 0.8108854293823242 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " if len(positions) > 0:\n print(\"positions:\")\n for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL, vault_address=vault)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)", "score": 0.803346574306488 }, { "filename": "hyperliquid/info.py", "retrieved_chunk": " \"\"\"Retrieve trading details about a user.\n POST /info\n Args:\n address (str): Onchain address in 42-character hexadecimal format;\n e.g. 0x0000000000000000000000000000000000000000.\n Returns:\n {\n assetPositions: [\n {\n position: {", "score": 0.7998929023742676 }, { "filename": "examples/basic_order.py", "retrieved_chunk": " for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":", "score": 0.7959688305854797 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7920569181442261 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " def set_continuous_mode(self, value: bool):\n \"\"\"Set the continuous mode value.\"\"\"\n self.continuous_mode = value\n def set_speak_mode(self, value: bool):\n \"\"\"Set the speak mode value.\"\"\"\n self.speak_mode = value\n def set_fast_llm_model(self, value: str):\n \"\"\"Set the fast LLM model value.\"\"\"\n self.fast_llm_model = value\n def set_smart_llm_model(self, value: str):", "score": 0.6793109178543091 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.6585475206375122 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/memory/pinecone.py", "retrieved_chunk": "import pinecone\nfrom memory.base import MemoryProviderSingleton, get_ada_embedding\nclass PineconeMemory(MemoryProviderSingleton):\n def __init__(self, cfg):\n pinecone_api_key = cfg.pinecone_api_key\n pinecone_region = cfg.pinecone_region\n pinecone.init(api_key=pinecone_api_key, environment=pinecone_region)\n dimension = 1536\n metric = \"cosine\"\n pod_type = \"p1\"", "score": 0.6583747267723083 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " None\n \"\"\"\n try:\n with open(config_file) as file:\n config_params = yaml.load(file, Loader=yaml.FullLoader)\n except FileNotFoundError:\n config_params = {}\n self.openai_api_base = config_params.get(\"azure_api_base\", \"\")\n self.openai_api_version = config_params.get(\"azure_api_version\", \"\")\n self.azure_model_to_deployment_id_map = config_params.get(\"azure_model_map\", [])", "score": 0.6548903584480286 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7611644268035889 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.7016403675079346 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": "import os\nimport sys\n# Probably a better way:\nsys.path.append(os.path.abspath('../scripts'))\nfrom memory.local import LocalCache\ndef MockConfig():\n return type('MockConfig', (object,), {\n 'debug_mode': False,\n 'continuous_mode': False,\n 'speak_mode': False,", "score": 0.6544678211212158 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " def test_clear(self):\n self.cache.clear()\n self.assertEqual(self.cache.data, [\"\"])\n def test_get(self):\n text = \"Sample text\"\n self.cache.add(text)\n result = self.cache.get(text)\n self.assertEqual(result, [text])\n def test_get_relevant(self):\n text1 = \"Sample text 1\"", "score": 0.6544005870819092 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/unit/json_tests.py", "retrieved_chunk": " obj = fix_and_parse_json(json_str)\n self.assertEqual(obj, {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_minor(self):\n # Test that an invalid JSON string can be fixed with gpt\n json_str = '{\"name\": \"John\", \"age\": 30, \"city\": \"New York\",}'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=False), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_major_with_gpt(self):\n # Test that an invalid JSON string raises an error when try_to_fix_with_gpt is False\n json_str = 'BEGIN: \"name\": \"John\" - \"age\": 30 - \"city\": \"New York\" :END'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=True), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})", "score": 0.6531814336776733 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7879355549812317 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " self.fast_llm_model = os.getenv(\"FAST_LLM_MODEL\", \"gpt-3.5-turbo\")\n self.smart_llm_model = os.getenv(\"SMART_LLM_MODEL\", \"gpt-4\")\n self.fast_token_limit = int(os.getenv(\"FAST_TOKEN_LIMIT\", 4000))\n self.smart_token_limit = int(os.getenv(\"SMART_TOKEN_LIMIT\", 8000))\n self.openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n self.temperature = int(os.getenv(\"TEMPERATURE\", \"1\"))\n self.use_azure = False\n self.use_azure = os.getenv(\"USE_AZURE\") == 'True'\n self.execute_local_commands = os.getenv('EXECUTE_LOCAL_COMMANDS', 'False') == 'True'\n if self.use_azure:", "score": 0.7112647294998169 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " None\n \"\"\"\n try:\n with open(config_file) as file:\n config_params = yaml.load(file, Loader=yaml.FullLoader)\n except FileNotFoundError:\n config_params = {}\n self.openai_api_base = config_params.get(\"azure_api_base\", \"\")\n self.openai_api_version = config_params.get(\"azure_api_version\", \"\")\n self.azure_model_to_deployment_id_map = config_params.get(\"azure_model_map\", [])", "score": 0.6724676489830017 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " def set_continuous_mode(self, value: bool):\n \"\"\"Set the continuous mode value.\"\"\"\n self.continuous_mode = value\n def set_speak_mode(self, value: bool):\n \"\"\"Set the speak mode value.\"\"\"\n self.speak_mode = value\n def set_fast_llm_model(self, value: str):\n \"\"\"Set the fast LLM model value.\"\"\"\n self.fast_llm_model = value\n def set_smart_llm_model(self, value: str):", "score": 0.66703861951828 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.6532164216041565 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/integration/memory_tests.py", "retrieved_chunk": " k = 3\n relevant_texts = self.cache.get_relevant(query, k)\n print(f\"Top {k} relevant texts for the query '{query}':\")\n for i, text in enumerate(relevant_texts, start=1):\n print(f\"{i}. {text}\")\n self.assertEqual(len(relevant_texts), k)\n self.assertIn(self.example_texts[1], relevant_texts)\nif __name__ == '__main__':\n unittest.main()", "score": 0.8051888346672058 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/memory/pinecone.py", "retrieved_chunk": " # no metadata here. We may wish to change that long term.\n resp = self.index.upsert([(str(self.vec_num), vector, {\"raw_text\": data})])\n _text = f\"Inserting data into memory at index: {self.vec_num}:\\n data: {data}\"\n self.vec_num += 1\n return _text\n def get(self, data):\n return self.get_relevant(data, 1)\n def clear(self):\n self.index.delete(deleteAll=True)\n return \"Obliviated\"", "score": 0.7357969880104065 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/unit/test_browse_scrape_text.py", "retrieved_chunk": " result = scrape_text(\"https://www.example.com\")\n # Check that the function returns an error message\n assert result == \"Error: HTTP 404 error\"\n # Tests that scrape_text() properly handles HTML tags.\n def test_scrape_text_with_html_tags(self, mocker):\n # Create a mock response object with HTML containing tags\n html = \"<html><body><p>This is <b>bold</b> text.</p></body></html>\"\n mock_response = mocker.Mock()\n mock_response.status_code = 200\n mock_response.text = html", "score": 0.6981557011604309 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/test_json_parser.py", "retrieved_chunk": "import unittest\nimport tests.context\nfrom scripts.json_parser import fix_and_parse_json\nclass TestParseJson(unittest.TestCase):\n def test_valid_json(self):\n # Test that a valid JSON string is parsed correctly\n json_str = '{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}'\n obj = fix_and_parse_json(json_str)\n self.assertEqual(obj, {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_minor(self):", "score": 0.6973865032196045 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/memory/base.py", "retrieved_chunk": " def clear(self):\n pass\n @abc.abstractmethod\n def get_relevant(self, data, num_relevant=5):\n pass\n @abc.abstractmethod\n def get_stats(self):\n pass", "score": 0.6925964951515198 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.7179654240608215 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " 'memory_index': 'auto-gpt',\n })\nclass TestLocalCache(unittest.TestCase):\n def setUp(self):\n self.cfg = MockConfig()\n self.cache = LocalCache(self.cfg)\n def test_add(self):\n text = \"Sample text\"\n self.cache.add(text)\n self.assertIn(text, self.cache.data.texts)", "score": 0.7114947438240051 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7042312026023865 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " def test_clear(self):\n self.cache.clear()\n self.assertEqual(self.cache.data, [\"\"])\n def test_get(self):\n text = \"Sample text\"\n self.cache.add(text)\n result = self.cache.get(text)\n self.assertEqual(result, [text])\n def test_get_relevant(self):\n text1 = \"Sample text 1\"", "score": 0.6941251754760742 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": "import os\nimport sys\n# Probably a better way:\nsys.path.append(os.path.abspath('../scripts'))\nfrom memory.local import LocalCache\ndef MockConfig():\n return type('MockConfig', (object,), {\n 'debug_mode': False,\n 'continuous_mode': False,\n 'speak_mode': False,", "score": 0.6900080442428589 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7317141890525818 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " None\n \"\"\"\n try:\n with open(config_file) as file:\n config_params = yaml.load(file, Loader=yaml.FullLoader)\n except FileNotFoundError:\n config_params = {}\n self.openai_api_base = config_params.get(\"azure_api_base\", \"\")\n self.openai_api_version = config_params.get(\"azure_api_version\", \"\")\n self.azure_model_to_deployment_id_map = config_params.get(\"azure_model_map\", [])", "score": 0.6634290814399719 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " self.fast_llm_model = os.getenv(\"FAST_LLM_MODEL\", \"gpt-3.5-turbo\")\n self.smart_llm_model = os.getenv(\"SMART_LLM_MODEL\", \"gpt-4\")\n self.fast_token_limit = int(os.getenv(\"FAST_TOKEN_LIMIT\", 4000))\n self.smart_token_limit = int(os.getenv(\"SMART_TOKEN_LIMIT\", 8000))\n self.openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n self.temperature = int(os.getenv(\"TEMPERATURE\", \"1\"))\n self.use_azure = False\n self.use_azure = os.getenv(\"USE_AZURE\") == 'True'\n self.execute_local_commands = os.getenv('EXECUTE_LOCAL_COMMANDS', 'False') == 'True'\n if self.use_azure:", "score": 0.6624495983123779 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/unit/json_tests.py", "retrieved_chunk": " obj = fix_and_parse_json(json_str)\n self.assertEqual(obj, {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_minor(self):\n # Test that an invalid JSON string can be fixed with gpt\n json_str = '{\"name\": \"John\", \"age\": 30, \"city\": \"New York\",}'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=False), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_major_with_gpt(self):\n # Test that an invalid JSON string raises an error when try_to_fix_with_gpt is False\n json_str = 'BEGIN: \"name\": \"John\" - \"age\": 30 - \"city\": \"New York\" :END'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=True), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})", "score": 0.6607813835144043 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.6494443416595459 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " json_string = json_match.group(0)\n logger.typewriter_log(title=\"Apparently json was fixed.\", title_color=Fore.GREEN)\n if cfg.speak_mode and cfg.debug_mode:\n speak.say_text(\"Apparently json was fixed.\")\n else:\n raise ValueError(\"No valid JSON object found\")\n except (json.JSONDecodeError, ValueError) as e:\n if cfg.speak_mode:\n speak.say_text(\"Didn't work. I will have to ignore this response then.\")\n logger.error(\"Error: Invalid JSON, setting it to empty JSON now.\\n\")", "score": 0.7176890969276428 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " command_name, arguments = cmd.get_command(attempt_to_fix_json_by_finding_outermost_brackets(assistant_reply))\n if cfg.speak_mode:\n speak.say_text(f\"I want to execute {command_name}\")\n except Exception as e:\n logger.error(\"Error: \\n\", str(e))\n if not cfg.continuous_mode and next_action_count == 0:\n ### GET USER AUTHORIZATION TO EXECUTE COMMAND ###\n # Get key press: Prompt the user to press enter to continue or escape\n # to exit\n user_input = \"\"", "score": 0.6993617415428162 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " for i, goal in enumerate(ai_goals):\n full_prompt += f\"{i+1}. {goal}\\n\"\n full_prompt += f\"\\n\\n{prompt}\"\n return full_prompt\ndef construct_prompt():\n \"\"\"Construct the prompt for the AI to respond to\"\"\"\n config = AIConfig.load()\n if config.ai_name:\n logger.typewriter_log(\n f\"Welcome back! \",", "score": 0.6962935924530029 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " memory_to_add = f\"Assistant Reply: {assistant_reply} \" \\\n f\"\\nResult: {result} \" \\\n f\"\\nHuman Feedback: {user_input} \"\n memory.add(memory_to_add)\n # Check if there's a result from the command append it to the message\n # history\n if result is not None:\n full_message_history.append(chat.create_chat_message(\"system\", result))\n logger.typewriter_log(\"SYSTEM: \", Fore.YELLOW, result)\n else:", "score": 0.6956617832183838 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/commands.py", "retrieved_chunk": " agent_response = agents.message_agent(key, message)\n else:\n return \"Invalid key, must be an integer or a string.\"\n # Speak response\n if cfg.speak_mode:\n speak.say_text(agent_response, 1)\n return agent_response\ndef list_agents():\n \"\"\"List all agents\"\"\"\n return agents.list_agents()", "score": 0.6953335404396057 } ]

[ { "filename": "examples/basic_order.py", "retrieved_chunk": " for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)\n # Cancel the order\n if order_result[\"status\"] == \"ok\":", "score": 0.8887161016464233 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " if len(positions) > 0:\n print(\"positions:\")\n for position in positions:\n print(json.dumps(position, indent=2))\n else:\n print(\"no open positions\")\n # Place an order that should rest by setting the price very low\n exchange = Exchange(account, constants.TESTNET_API_URL, vault_address=vault)\n order_result = exchange.order(\"ETH\", True, 0.2, 100, {\"limit\": {\"tif\": \"Gtc\"}})\n print(order_result)", "score": 0.8681995272636414 }, { "filename": "examples/basic_leverage_adjustment.py", "retrieved_chunk": " print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n exchange = Exchange(account, constants.TESTNET_API_URL)\n # Get the user state and print out leverage information for ETH\n user_state = info.user_state(account.address)\n print(\"Current leverage for ETH:\")\n print(json.dumps(user_state[\"assetPositions\"][exchange.coin_to_asset[\"ETH\"]][\"position\"][\"leverage\"], indent=2))\n # Set the ETH leverage to 21x (cross margin)\n print(exchange.update_leverage(21, \"ETH\"))\n # Set the ETH leverage to 22x (isolated margin)", "score": 0.8245055675506592 }, { "filename": "tests/signing_test.py", "retrieved_chunk": "def test_l1_action_signing_tpsl_order_matches():\n wallet = eth_account.Account.from_key(\"0x0123456789012345678901234567890123456789012345678901234567890123\")\n order_spec: OrderSpec = {\n \"order\": {\n \"asset\": 1,\n \"isBuy\": True,\n \"reduceOnly\": False,\n \"limitPx\": 100,\n \"sz\": 100,\n },", "score": 0.8014195561408997 }, { "filename": "examples/basic_vault.py", "retrieved_chunk": " # Change this address to a vault that you lead\n vault = \"0x1719884eb866cb12b2287399b15f7db5e7d775ea\"\n print(\"Running with account address:\", account.address)\n info = Info(constants.TESTNET_API_URL, skip_ws=True)\n # Get the user state and print out position information\n user_state = info.user_state(account.address)\n positions = []\n for position in user_state[\"assetPositions\"]:\n if float(position[\"position\"][\"szi\"]) != 0:\n positions.append(position[\"position\"])", "score": 0.7921328544616699 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7374572157859802 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/unit/json_tests.py", "retrieved_chunk": " obj = fix_and_parse_json(json_str)\n self.assertEqual(obj, {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_minor(self):\n # Test that an invalid JSON string can be fixed with gpt\n json_str = '{\"name\": \"John\", \"age\": 30, \"city\": \"New York\",}'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=False), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})\n def test_invalid_json_major_with_gpt(self):\n # Test that an invalid JSON string raises an error when try_to_fix_with_gpt is False\n json_str = 'BEGIN: \"name\": \"John\" - \"age\": 30 - \"city\": \"New York\" :END'\n self.assertEqual(fix_and_parse_json(json_str, try_to_fix_with_gpt=True), {\"name\": \"John\", \"age\": 30, \"city\": \"New York\"})", "score": 0.6731493473052979 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " None\n \"\"\"\n try:\n with open(config_file) as file:\n config_params = yaml.load(file, Loader=yaml.FullLoader)\n except FileNotFoundError:\n config_params = {}\n self.openai_api_base = config_params.get(\"azure_api_base\", \"\")\n self.openai_api_version = config_params.get(\"azure_api_version\", \"\")\n self.azure_model_to_deployment_id_map = config_params.get(\"azure_model_map\", [])", "score": 0.6297682523727417 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.629446804523468 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " self.fast_llm_model = os.getenv(\"FAST_LLM_MODEL\", \"gpt-3.5-turbo\")\n self.smart_llm_model = os.getenv(\"SMART_LLM_MODEL\", \"gpt-4\")\n self.fast_token_limit = int(os.getenv(\"FAST_TOKEN_LIMIT\", 4000))\n self.smart_token_limit = int(os.getenv(\"SMART_TOKEN_LIMIT\", 8000))\n self.openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n self.temperature = int(os.getenv(\"TEMPERATURE\", \"1\"))\n self.use_azure = False\n self.use_azure = os.getenv(\"USE_AZURE\") == 'True'\n self.execute_local_commands = os.getenv('EXECUTE_LOCAL_COMMANDS', 'False') == 'True'\n if self.use_azure:", "score": 0.6256197690963745 } ]

[ { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/main.py", "retrieved_chunk": " logger.typewriter_log(\"Speak Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_speak_mode(True)\n if args.gpt3only:\n logger.typewriter_log(\"GPT3.5 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_smart_llm_model(cfg.fast_llm_model)\n if args.gpt4only:\n logger.typewriter_log(\"GPT4 Only Mode: \", Fore.GREEN, \"ENABLED\")\n cfg.set_fast_llm_model(cfg.smart_llm_model)\n if args.debug:\n logger.typewriter_log(\"Debug Mode: \", Fore.GREEN, \"ENABLED\")", "score": 0.7729120850563049 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/tests/local_cache_test.py", "retrieved_chunk": " text2 = \"Sample text 2\"\n self.cache.add(text1)\n self.cache.add(text2)\n result = self.cache.get_relevant(text1, 1)\n self.assertEqual(result, [text1])\n def test_get_stats(self):\n text = \"Sample text\"\n self.cache.add(text)\n stats = self.cache.get_stats()\n self.assertEqual(stats, (1, self.cache.data.embeddings.shape))", "score": 0.6909914016723633 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " self.fast_llm_model = os.getenv(\"FAST_LLM_MODEL\", \"gpt-3.5-turbo\")\n self.smart_llm_model = os.getenv(\"SMART_LLM_MODEL\", \"gpt-4\")\n self.fast_token_limit = int(os.getenv(\"FAST_TOKEN_LIMIT\", 4000))\n self.smart_token_limit = int(os.getenv(\"SMART_TOKEN_LIMIT\", 8000))\n self.openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n self.temperature = int(os.getenv(\"TEMPERATURE\", \"1\"))\n self.use_azure = False\n self.use_azure = os.getenv(\"USE_AZURE\") == 'True'\n self.execute_local_commands = os.getenv('EXECUTE_LOCAL_COMMANDS', 'False') == 'True'\n if self.use_azure:", "score": 0.6796284914016724 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " def set_continuous_mode(self, value: bool):\n \"\"\"Set the continuous mode value.\"\"\"\n self.continuous_mode = value\n def set_speak_mode(self, value: bool):\n \"\"\"Set the speak mode value.\"\"\"\n self.speak_mode = value\n def set_fast_llm_model(self, value: str):\n \"\"\"Set the fast LLM model value.\"\"\"\n self.fast_llm_model = value\n def set_smart_llm_model(self, value: str):", "score": 0.668586254119873 }, { "filename": "Chaos-GPT-master/Auto-GPT-master/scripts/config.py", "retrieved_chunk": " None\n \"\"\"\n try:\n with open(config_file) as file:\n config_params = yaml.load(file, Loader=yaml.FullLoader)\n except FileNotFoundError:\n config_params = {}\n self.openai_api_base = config_params.get(\"azure_api_base\", \"\")\n self.openai_api_version = config_params.get(\"azure_api_version\", \"\")\n self.azure_model_to_deployment_id_map = config_params.get(\"azure_model_map\", [])", "score": 0.65462327003479 } ]

[ { "filename": "autopr/services/agent_service.py", "retrieved_chunk": " ):\n # Get the agent\n agent_type = self.agents[agent_id]\n agent = agent_type(\n repo=self.repo,\n rail_service=self.rail_service,\n chain_service=self.chain_service,\n diff_service=self.diff_service,\n commit_service=self.commit_service,\n publish_service=self.publish_service,", "score": 0.8989429473876953 }, { "filename": "autopr/services/agent_service.py", "retrieved_chunk": " repo: Repo,\n ):\n self.repo = repo\n self.publish_service = publish_service\n self.rail_service = rail_service\n self.chain_service = chain_service\n self.diff_service = diff_service\n self.commit_service = commit_service\n self.action_service = action_service\n # Load all agents in the `autopr/agents` directory", "score": 0.8659273982048035 }, { "filename": "autopr/agents/base.py", "retrieved_chunk": " self.chain_service = chain_service\n self.diff_service = diff_service\n self.commit_service = commit_service\n self.publish_service = publish_service\n self.action_service = action_service\n self.repo = repo\n self.log = structlog.get_logger(service=\"brain\",\n id=self.id)\n if kwargs:\n self.log.warning(\"Agent did not use additional options\", kwargs=kwargs)", "score": 0.8508375883102417 }, { "filename": "autopr/actions/edit_file.py", "retrieved_chunk": " # Check if file exists\n repo_path = self.repo.working_tree_dir\n assert repo_path\n filepath = os.path.join(repo_path, args.filepath)\n if not os.path.exists(filepath):\n create_file_action = NewFile(\n repo=self.repo,\n rail_service=self.rail_service,\n chain_service=self.chain_service,\n publish_service=self.publish_service,", "score": 0.8208250999450684 }, { "filename": "autopr/services/action_service.py", "retrieved_chunk": "</rail>\n\"\"\"\n def instantiate_action(\n self,\n action_type: Type[Action],\n ):\n return action_type(\n repo=self.repo,\n rail_service=self.rail_service,\n chain_service=self.chain_service,", "score": 0.811539351940155 } ]

[ { "filename": "autopr/services/rail_service.py", "retrieved_chunk": " Runs a PromptRail, asking the LLM a question and parsing the response into `PromptRail.output_type`.\n :param rail:\n :return:\n \"\"\"\n # Make sure the prompt is not too long\n max_length = self.context_limit - self.min_tokens\n success = rail.ensure_token_length(max_length)\n if not success:\n return None\n # Run the rail", "score": 0.8106393218040466 }, { "filename": "autopr/services/chain_service.py", "retrieved_chunk": " # Make sure the prompt is not too long\n max_length = self.context_limit - self.min_tokens\n success = chain.ensure_token_length(max_length)\n if not success:\n return None\n if chain.output_parser:\n parser = chain.output_parser\n else:\n parser = None\n prompt_value = self._get_model_template(chain, parser)", "score": 0.8047243356704712 }, { "filename": "autopr/repos/completions_repo.py", "retrieved_chunk": " )\n if examples is None:\n examples = []\n if system_prompt is None:\n system_prompt = \"You are a helpful assistant.\"\n if temperature is None:\n temperature = self.temperature\n length = len(self.tokenizer.encode(prompt))\n max_tokens = min(self.max_tokens, self.context_limit - length)\n self.log.info(", "score": 0.7904046773910522 }, { "filename": "autopr/repos/completions_repo.py", "retrieved_chunk": " prompt: str,\n system_prompt: str,\n examples: list[tuple[str, str]],\n max_tokens: int,\n temperature: float,\n ) -> str:\n prompt = system_prompt\n for example in examples:\n prompt += f\"\\n\\n{example[0]}\\n{example[1]}\"\n prompt += f\"\\n\\n{prompt}\"", "score": 0.7724106311798096 }, { "filename": "autopr/actions/look_at_files.py", "retrieved_chunk": " ]),\n 'token_limit': str(self.token_limit),\n }\n def trim_params(self) -> bool:\n if trim_chunk(self.selected_file_contents):\n return True\n return super().trim_params()\nclass InspectFiles(Action):\n \"\"\"\n Iteratively select files to look at, taking notes while looking at them.", "score": 0.7661958336830139 } ]

[ { "filename": "autopr/services/commit_service.py", "retrieved_chunk": " self.repo.delete_head(self.branch_name, force=True)\n # Create new branch with create_new_ref\n self.log.debug(f'Creating new branch {self.branch_name}...')\n self.repo.create_head(self.branch_name, self.base_branch_name)\n # Checkout new branch\n self.repo.heads[self.branch_name].checkout()\n # Create empty commit\n self.commit(self._empty_commit_message)\n def ensure_branch_exists(self):\n # Fetch", "score": 0.8620434403419495 }, { "filename": "autopr/services/commit_service.py", "retrieved_chunk": " self.log = structlog.get_logger(service=\"commit\")\n def overwrite_new_branch(self):\n # Checkout and pull base branch\n self.log.debug(f'Checking out {self.base_branch_name}...')\n self.repo.heads[self.base_branch_name].checkout()\n self.log.debug('Pulling latest changes...')\n self.repo.remotes.origin.pull()\n # If branch already exists, delete it\n if self.branch_name in self.repo.heads:\n self.log.debug(f'Deleting existing branch {self.branch_name}...')", "score": 0.8357851505279541 }, { "filename": "autopr/actions/edit_file.py", "retrieved_chunk": " # Check if file exists\n repo_path = self.repo.working_tree_dir\n assert repo_path\n filepath = os.path.join(repo_path, args.filepath)\n if not os.path.exists(filepath):\n create_file_action = NewFile(\n repo=self.repo,\n rail_service=self.rail_service,\n chain_service=self.chain_service,\n publish_service=self.publish_service,", "score": 0.815680742263794 }, { "filename": "autopr/services/agent_service.py", "retrieved_chunk": " ):\n # Get the agent\n agent_type = self.agents[agent_id]\n agent = agent_type(\n repo=self.repo,\n rail_service=self.rail_service,\n chain_service=self.chain_service,\n diff_service=self.diff_service,\n commit_service=self.commit_service,\n publish_service=self.publish_service,", "score": 0.8106805086135864 }, { "filename": "autopr/services/commit_service.py", "retrieved_chunk": " repo: Repo,\n repo_path: str,\n branch_name: str,\n base_branch_name: str,\n ):\n self.repo = repo\n self.repo_path = repo_path\n self.branch_name = branch_name\n self.base_branch_name = base_branch_name\n self._empty_commit_message = \"[placeholder]\"", "score": 0.8083751797676086 } ]

[ { "filename": "autopr/services/publish_service.py", "retrieved_chunk": " def _publish_comment(self, text: str, issue_number: int) -> Optional[str]:\n \"\"\"\n Publish a comment to the issue (pull requests are also issues).\n Parameters\n ----------\n text: str\n The text to comment\n issue_number: Optional[int]\n The issue number to comment on. If None, should comment on the PR.\n \"\"\"", "score": 0.8035924434661865 }, { "filename": "autopr/models/events.py", "retrieved_chunk": " Event triggered when a label is added to an issue.\n \"\"\"\n event_type: Literal['issue_label'] = 'issue_label'\n issue: Issue\n label: str\nclass PullRequestCommentEvent(Event):\n \"\"\"\n Event triggered when a comment is added to a pull request.\n \"\"\"\n event_type: Literal['pull_request_comment'] = 'pull_request_comment'", "score": 0.7986927032470703 }, { "filename": "autopr/services/publish_service.py", "retrieved_chunk": " The title of the pull request\n body: str\n The body of the pull request\n \"\"\"\n if self.pr_number is None:\n self.update()\n if self.pr_number is None:\n raise RuntimeError(\"Error creating pull request\")\n else:\n self._set_title(title)", "score": 0.7962319850921631 }, { "filename": "autopr/agents/plan_and_code.py", "retrieved_chunk": " context_headings={\n 'pull_request': \"Pull request that we are adding commits to\",\n 'request': \"Request that we are responding to\",\n }\n )\n self.log.info(f\"Committed {current_commit.commit_message}\")\n def create_pull_request(\n self,\n event: IssueLabelEvent,\n ) -> None:", "score": 0.7901350259780884 }, { "filename": "autopr/services/publish_service.py", "retrieved_chunk": " # GitHub comment length limit is ~262144, not 65536 as stated in the docs\n self.max_comment_length = 260000\n if issue is not None:\n self.title: str = f\"Fix #{issue.number}: {issue.title}\"\n else:\n self.title: str = \"AutoPR\"\n self.root_section = UpdateSection(\n level=0,\n title=\"root\",\n )", "score": 0.7836445569992065 } ]

[ { "filename": "autopr/actions/utils/file.py", "retrieved_chunk": " if not os.path.exists(path):\n log.error(f\"File {filepath} not in repo\")\n return None\n if not os.path.isfile(path):\n log.error(f\"{filepath} is not a file\")\n return None\n with open(path, 'r') as f:\n lines = split_into_lines(f.read())\n code_hunk: list[tuple[int, str]] = []\n # Get and limit line numbers", "score": 0.7690800428390503 }, { "filename": "autopr/services/rail_service.py", "retrieved_chunk": " with open(constants_file, \"r\") as f:\n xml = f.read()\n parser = ET.XMLParser(encoding=\"utf-8\")\n parsed_constants = ET.fromstring(xml, parser=parser)\n for child in parsed_constants:\n if isinstance(child, ET._Comment):\n continue\n if isinstance(child, str):\n continue\n constant_name = child.tag", "score": 0.7082762718200684 }, { "filename": "autopr/actions/edit_file.py", "retrieved_chunk": " )\n create_args = NewFile.Arguments(\n filepath=args.filepath,\n description=args.description,\n )\n self.log.warning(f\"File {filepath} does not exist, creating it instead.\")\n return create_file_action.run(create_args, context)\n self.publish_service.update_section(title=f\"✍️ Editing file: {args.filepath}\")\n # Grab file contents\n with open(filepath, \"r\") as f:", "score": 0.6943492889404297 }, { "filename": "autopr/services/diff_service.py", "retrieved_chunk": "class GitApplyService(DiffService):\n def apply_diff(self, diff: DiffStr, check: bool = False) -> None:\n with tempfile.NamedTemporaryFile() as f:\n f.write(diff.encode())\n f.flush()\n log.debug('Applying diff...')\n self.repo.git.execute([\"git\",\n \"apply\",\n \"--allow-empty\",\n f.name])", "score": 0.6937148571014404 }, { "filename": "autopr/actions/utils/file.py", "retrieved_chunk": " def __str__(self):\n code_hunks_s = '\\n\\n'.join(\n [str(code_hunk) for code_hunk in self.code_hunks]\n )\n return f\">>> File: {self.filepath}\\n\\n\" + code_hunks_s\ndef split_into_lines(text: str) -> list[str]:\n lines = text.splitlines()\n # If text ends with a newline, we want to keep that as a line\n if text.rstrip() != text:\n lines.append(\"\")", "score": 0.6910367608070374 } ]

[ { "filename": "python/products/test_product_api_solution.py", "retrieved_chunk": " self.assertEqual(response['body'], '[{\"id\": \"1\", \"name\": \"test\", \"description\": \"test\"}]')\n # Patch get_products and test lambda_handler returns multiple records\n @patch('product_api.get_products')\n def test_lambda_handler_multiple(self, mock_get_products):\n mock_get_products.return_value = [{'id': '1', 'name': 'test', 'description': 'test'}, {'id': '2', 'name': 'test2', 'description': 'test2'}]\n response = product_api.lambda_handler(None, None)\n self.assertEqual(response['statusCode'], 200)\n self.assertEqual(response['body'], '[{\"id\": \"1\", \"name\": \"test\", \"description\": \"test\"}, {\"id\": \"2\", \"name\": \"test2\", \"description\": \"test2\"}]')", "score": 0.38580435514450073 }, { "filename": "python/users/test_user_api.py", "retrieved_chunk": " }\n response = user_api.lambda_handler(event, context=None)\n self.assertEqual(response['statusCode'], 200)\n @patch('user_api.send_message_to_sqs', MagicMock)\n def test_invalid_email_should_return_400(self):\n body = {\n \"username\": \"john\",\n \"email\": \"NOT_A_VALID_EMAIL_ADDRESS\",\n \"first_name\": \"John\",\n \"last_name\": \"Doe\",", "score": 0.37309789657592773 }, { "filename": "python/users/test_user_api.py", "retrieved_chunk": "import json \nfrom unittest import TestCase\nimport user_api \nfrom unittest.mock import patch, MagicMock\nclass TestUserApi(TestCase):\n @patch('user_api.send_message_to_sqs', MagicMock)\n def test_valid_message_should_return_200(self):\n body = {\n \"username\": \"john\",\n \"email\": \"john@example.com\",", "score": 0.367705762386322 }, { "filename": "python/images/image_api_solution.py", "retrieved_chunk": "import os\nimport boto3\nimport json\nimport base64\nBUCKET_NAME = os.getenv(\"BUCKET_NAME\", default=\"mybucket\")\ns3 = boto3.client('s3')\n# Upload the image to S3\ndef upload_image_to_s3(key, file, type):\n print('Uploading image to S3')\n s3.put_object(", "score": 0.3656175434589386 }, { "filename": "python/images/image_api.py", "retrieved_chunk": "import os\nimport boto3\nimport json\nimport base64\nBUCKET_NAME = os.getenv(\"BUCKET_NAME\", default=\"mybucket\")\ns3 = boto3.client('s3')\n# Upload the image to S3\ndef upload_image_to_s3(key, file, type):\n print('Uploading image to S3')\n s3.put_object(", "score": 0.3656175434589386 } ]

[ { "filename": "core/db/tables.py", "retrieved_chunk": " email: Optional[str]\n password: str\n api_key: str\n created: datetime = Field(default_factory=datetime.utcnow, nullable=False)\n last_updated: datetime = Field(default_factory=datetime.utcnow, nullable=False)\nclass Service(SQLModel, table=True):\n id: str = Field(primary_key=True)\n name: str = Field(index=True)\n description: str = Field(max_length=256, default=None)\n service_type: Optional[str] = Field(default=None, foreign_key=\"servicetype.name\", nullable=True)", "score": 0.6543365120887756 }, { "filename": "api/main.py", "retrieved_chunk": "from fastapi import FastAPI, Request\nfrom fastapi.responses import JSONResponse, HTMLResponse\nfrom fastapi.staticfiles import StaticFiles\nfrom api.services import service, admin\nfrom core.addons.exceptions import APIError\nfastapi = FastAPI(title=\"NetORC\", version=\"pre-release\")\n# from api.headers import require_general_authentication_header\n# dependencies=[require_general_authentication_header]\nfastapi.include_router(service.router)\nfastapi.include_router(admin.router)", "score": 0.6509900689125061 }, { "filename": "core/security/user.py", "retrieved_chunk": " user: User object\n session: database session\n Returns:\n user: database user object\n \"\"\"\n user.password = pbkdf2_sha256.hash(user.password)\n user.api_key = pbkdf2_sha256.hash(user.api_key)\n with session() as _session:\n try:\n _session.add(user)", "score": 0.642302930355072 }, { "filename": "core/task/decorators.py", "retrieved_chunk": " \"\"\"\n @wraps(func)\n def wrapper(*args, **kwargs):\n if \"task_lock_key\" in kwargs:\n task_lock_key = kwargs.get(\"task_lock_key\")\n logger.debug(\n \"Found task lock key for %s, using: %s as key\",\n func.__name__,\n task_lock_key,\n )", "score": 0.6292687058448792 }, { "filename": "api/services/admin.py", "retrieved_chunk": " setattr(user, k, v)\n try:\n db_user = create_user(user)\n return db_user\n except Exception as exc:\n raise APIError(status_code=500, code=\"Post User\", reason=\"Runtime error occurred\") from exc\n@router.patch(\"/users\")\ndef patch_users():\n pass\n@router.delete(\"/users\")", "score": 0.6260621547698975 } ]

[ { "filename": "autopr/actions/plan_pr.py", "retrieved_chunk": " )\n if pr_desc is None or not isinstance(pr_desc, PullRequestDescription):\n raise ValueError('Error proposing pull request')\n return pr_desc\n def run(\n self,\n args: Action.Arguments,\n context: ContextDict,\n ) -> ContextDict:\n self.publish_service.update_section('📝 Planning pull request')", "score": 0.8444150686264038 }, { "filename": "autopr/services/action_service.py", "retrieved_chunk": " except pydantic.ValidationError as e:\n self.log.error(\"Guardrails failed to parse action arguments\", error=e)\n return None\n return args\n def pick_action(\n self,\n action_ids: Collection[str],\n context: ContextDict,\n include_finished: bool = False,\n context_headings: Optional[dict[str, str]] = None,", "score": 0.8376526832580566 }, { "filename": "autopr/tests/test_rail_specs.py", "retrieved_chunk": " class Arguments(Action.Arguments):\n a: str\n b: str\n output_spec = \"<string name='a'/><string name='b'/>\"\n def run(self, arguments: Arguments, context: ContextDict) -> ContextDict:\n return context\nclass B(Action):\n id = \"b\"\n def run(self, arguments: Action.Arguments, context: ContextDict) -> ContextDict:\n return context", "score": 0.8367109298706055 }, { "filename": "autopr/actions/plan_pr.py", "retrieved_chunk": " # Get issue\n if 'issue' not in context:\n raise ValueError('No `issue` key in context')\n issue = context['issue']\n if not isinstance(issue, Issue):\n raise ValueError(f'Context `issue` is type {type(issue)}, not Issue')\n # Get notes\n if 'notes' not in context:\n raise ValueError('No `notes` key in context')\n notes = context['notes']", "score": 0.8307711482048035 }, { "filename": "autopr/services/action_service.py", "retrieved_chunk": " # Run the action\n context = action.run(args, context)\n self.publish_service.end_section()\n return context\n def ask_for_action_arguments(\n self,\n action_type: Type[Action],\n context: ContextDict,\n ) -> Optional[Action.Arguments]:\n if action_type.Arguments is Action.Arguments:", "score": 0.8305503129959106 } ]

[ { "filename": "src/routes/users.py", "retrieved_chunk": " \"\"\"\n Take user to ban list\n Arguments:\n user_id (int): Get the username from the url path\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: banned user\n \"\"\"\n ban = await repository_users.ban_user(user_id, db)\n if ban is None:", "score": 0.9168760776519775 }, { "filename": "src/repository/images.py", "retrieved_chunk": " If there is an image it changes its description to what was provided in the body.\n Args:\n body (ImageModel): The ImageModel object to be created.\n image_id(int): The id of the desired Image object.\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object with the updated description\n \"\"\"\n image = await get_image_from_id(image_id, user, db)", "score": 0.9136931300163269 }, { "filename": "src/routes/comments.py", "retrieved_chunk": " Arguments:\n comment_id (int): ID of the comment to be deleted\n db (Session): SQLAlchemy session object for accessing the database\n body (CommentBase): Pass the comment_text from the request body to the function\n current_user (User): the current user attempting to edite the comment\n Returns:\n Comment: the Comment object representing the modified comment,\n \"\"\"\n updated_comment = await edit_comment(comment_id, body, db, current_user)\n if not updated_comment:", "score": 0.9067885875701904 }, { "filename": "src/routes/users.py", "retrieved_chunk": " body (UserUpdate): object with new role\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: object after the change operation\n \"\"\"\n user = await repository_users.update_user(body, user, db)\n if user is None:\n raise HTTPException(\n status_code=status.HTTP_404_NOT_FOUND, detail=\"NOT_FOUND\")", "score": 0.906532347202301 }, { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.9005826115608215 } ]

[ { "filename": "src/routes/ratings.py", "retrieved_chunk": " value from 1 to 5, and returns a JSON object containing information about the newly created rate.\n Arguments:\n image_id (int): rate id to be rated.\n rate (int): value from 1 to 5\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Rate: The new rate object\n \"\"\"\n new_rate = await repository_ratings.create_rate(image_id, rate, db, current_user)", "score": 0.9092355966567993 }, { "filename": "src/routes/ratings.py", "retrieved_chunk": " Arguments:\n image_id (int): Get the image_id from the url\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n dict: An average rating object\n \"\"\"\n average_rate = await repository_ratings.calculate_rating(image_id, db, current_user)\n if average_rate is None:\n raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=\"Rating not found or not available.\")", "score": 0.8895361423492432 }, { "filename": "src/repository/images.py", "retrieved_chunk": " db.refresh(image)\n return image\nasync def get_image_from_id(image_id: int, user: User, db: Session) -> Image | None:\n \"\"\"\n The get_image_from_id function takes in an image_id and a user, and returns the image with that id.\n Args:\n image_id (int): The id of the desired Image object.\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:", "score": 0.8827304840087891 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.8813209533691406 }, { "filename": "src/repository/images.py", "retrieved_chunk": " If there is an image it changes its description to what was provided in the body.\n Args:\n body (ImageModel): The ImageModel object to be created.\n image_id(int): The id of the desired Image object.\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object with the updated description\n \"\"\"\n image = await get_image_from_id(image_id, user, db)", "score": 0.879642903804779 } ]

[ { "filename": "src/database/db.py", "retrieved_chunk": " db = DBSession()\n try:\n yield db\n except SQLAlchemyError as err_sql:\n db.rollback()\n raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(err_sql))\n finally:\n db.close()", "score": 0.7806774377822876 }, { "filename": "tests/test_route_main.py", "retrieved_chunk": "from fastapi import status\ndef test_root(client):\n response = client.get(\"/\")\n assert response.status_code == status.HTTP_200_OK\n data = response.json()\n assert data[\"message\"] == \"Welcome to the FAST API from team 6\"\ndef test_healthchecker(client):\n response = client.get(\"/api/healthchecker\")\n assert response.status_code == status.HTTP_200_OK\n data = response.json()", "score": 0.7562044858932495 }, { "filename": "tests/test_unit_route_tags.py", "retrieved_chunk": " session: Create a new session for the test\n token: Authenticate the user\n Returns:\n A 404 status code\n \"\"\"\n new_tag_name = \"test_1\"\n response = client.put(\"/api/tag/999\", headers={\"Authorization\": f\"Bearer {token}\"}, json={\"tag_name\": new_tag_name})\n assert response.status_code == status.HTTP_404_NOT_FOUND, response.text\ndef test_delete_tag_found(client, session, token):\n \"\"\"", "score": 0.7535239458084106 }, { "filename": "tests/test_unit_route_tags.py", "retrieved_chunk": " session: Create a new database session for the test\n Returns:\n A 401 unauthorized status code\n \"\"\"\n token = \"not_valid\"\n response = client.post(\"/api/tag/%23test\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_401_UNAUTHORIZED, response.text\ndef test_create_tags_not_valid_tags(client, session, token):\n \"\"\"\n The test_create_tags_not_valid_tags function tests the POST /api/tag/ endpoint.", "score": 0.7521733641624451 }, { "filename": "src/routes/users.py", "retrieved_chunk": " Returns:\n User: object after the change operation\n \"\"\"\n user = await repository_users.change_role(body, user, db)\n if user is None:\n raise HTTPException(\n status_code=status.HTTP_404_NOT_FOUND, detail=\"NOT_FOUND\")\n return user\n@router.put(\"/ban_user\", response_model=UserResponse, dependencies=[Depends(allowed_operation_put)])\nasync def ban_user(user_id: int, db: Session = Depends(get_db)):", "score": 0.748233437538147 } ]

[ { "filename": "src/repository/tags.py", "retrieved_chunk": " db.delete(tag)\n db.commit()\n return tag\nasync def get_images_by_tag(tag: str, limit: int, offset: int, db: Session) -> List[Image] | None:\n \"\"\"\n The get_images function returns a list of images for the specified user.\n The limit and offset parameters are used to paginate the results.\n Arguments:\n tag (str): name of tag to find images\n offset (int): number of comments to skip in the search", "score": 0.9326821565628052 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Delete tag from database just for Administrator role\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Tag | None: tag object\n or None if the user have no permission to delete the tag or if no matching tag exists in the database\n \"\"\"\n tag = await find_tag(tag_name, db)\n if tag:", "score": 0.9184922575950623 }, { "filename": "src/routes/images.py", "retrieved_chunk": " db: Session = Depends(get_db)):\n \"\"\"\n The get_images function returns a list of images.\n Arguments:\n limit (int): Limit the number of images returned\n offset (int): Specify the number of records to skip before returning results\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n List[Image]: A list of images", "score": 0.9116551876068115 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.9032953977584839 }, { "filename": "src/routes/comments.py", "retrieved_chunk": " db: Session = Depends(get_db),\n skip: int = 0,\n limit: int = 10):\n \"\"\"\n Gets all comments of the specified image from the database.\n Arguments:\n skip (int): number of comments to skip in the search\n limit (int): maximum number of comments to retrieve\n image_id (int): ID of the image to retrieve comments for\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.8985374569892883 } ]

[ { "filename": "src/routes/auth.py", "retrieved_chunk": " db (Session): SQLAlchemy session object for accessing the database\n Returns:\n dict: JSON access_token - refresh_token - token_type\n \"\"\"\n token = credentials.credentials\n email = await auth_service.decode_refresh_token(token)\n user = await repository_users.get_user_by_email(email, db)\n if user.refresh_token != token:\n await repository_users.update_token(user, None, db)\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=\"Invalid refresh token\")", "score": 0.8425355553627014 }, { "filename": "src/routes/auth.py", "retrieved_chunk": " \"\"\"\n user = await repository_users.get_user_by_email(body.username, db)\n if user is None:\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=\"Invalid email\")\n if not user.is_active:\n raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=\"User is inactive\")\n if not auth_service.pwd_context.verify(body.password, user.password_checksum):\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=\"Invalid password\")\n # Generate JWT\n access_token = await auth_service.create_access_token(data={\"sub\": user.email})", "score": 0.799544095993042 }, { "filename": "src/routes/auth.py", "retrieved_chunk": " refresh_token = await auth_service.create_refresh_token(data={\"sub\": user.email})\n await repository_users.update_token(user, refresh_token, db)\n return {\"access_token\": access_token, \"refresh_token\": refresh_token, \"token_type\": \"bearer\"}\n@router.post(\"/logout\")\nasync def logout(credentials: HTTPAuthorizationCredentials = Security(security),\n db: Session = Depends(get_db),\n current_user: UserModel = Depends(auth_service.get_current_user)):\n \"\"\"\n The logout function is used to logout a user.\n It takes the credentials,", "score": 0.7623953223228455 }, { "filename": "src/routes/auth.py", "retrieved_chunk": " Returns:\n User: The created user\n \"\"\"\n exist_user = await repository_users.get_user_by_email(body.email, db)\n if exist_user:\n raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=\"Account already exists\")\n body.password_checksum = auth_service.pwd_context.hash(body.password_checksum)\n new_user = await repository_users.create_user(body, db)\n return new_user\n@router.post(\"/login\", response_model=TokenModel)", "score": 0.7575410604476929 }, { "filename": "tests/test_unit_route_tags.py", "retrieved_chunk": " client: Make requests to the api\n user: Create a user in the database\n session: Make queries to the database\n Returns:\n A valid access token\n \"\"\"\n response = client.post(\"/api/auth/signup\", json={\"login\": \"deadpool\", \"email\": \"deadpool@example.com\",\n \"password_checksum\": \"123456789\"})\n current_user: User = session.query(User).filter(User.email == user.get('email')).first()\n current_user.role = UserRole.Admin", "score": 0.7546124458312988 } ]

[ { "filename": "src/routes/images.py", "retrieved_chunk": " image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n image/png: streamingresponse\n \"\"\"\n image = await repository_images.get_image(image_id, current_user, db)\n if image is None:\n raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=\"Not Found\")\n qr_code = await CloudImage.create_qr_code_image(image.image_url)", "score": 0.849585771560669 }, { "filename": "src/routes/images.py", "retrieved_chunk": " db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: new image with the transformation applied\n \"\"\"\n image = await repository_images.get_image_from_id(body.id, current_user, db)\n if not image:\n raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=\"Not Found\")\n transformation_image_url = CloudImage.get_transformation_image(image.image_url, body.transformation)\n tags_in_text = None\n if len(image.tags) > 0:", "score": 0.8363937139511108 }, { "filename": "src/repository/images.py", "retrieved_chunk": " body (ImageModel): The ImageModel object to be created.\n image_url(str): Pass the image url to the database\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object\n \"\"\"\n image = Image(description=body.description, user=user, image_url=image_url, tags=await create_tags(body.tags_text, db))\n db.add(image)\n db.commit()", "score": 0.815595269203186 }, { "filename": "src/repository/users.py", "retrieved_chunk": " user = db.query(User).filter(User.id == body.id).first()\n if user:\n user.name = body.name\n user.email = body.email\n user.user_pic_url = body.user_pic_url\n user.password_checksum = auth_service.pwd_context.hash(body.password_checksum)\n user.updated_at = datetime.now()\n db.commit()\n return user\nasync def update_user_by_admin(body: UserUpdateAdmin, user: User, db: Session) -> User | None:", "score": 0.8036623597145081 }, { "filename": "src/routes/auth.py", "retrieved_chunk": " db (Session): SQLAlchemy session object for accessing the database\n Returns:\n dict: JSON access_token - refresh_token - token_type\n \"\"\"\n token = credentials.credentials\n email = await auth_service.decode_refresh_token(token)\n user = await repository_users.get_user_by_email(email, db)\n if user.refresh_token != token:\n await repository_users.update_token(user, None, db)\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=\"Invalid refresh token\")", "score": 0.8011260032653809 } ]

[ { "filename": "src/repository/tags.py", "retrieved_chunk": " tag.tag_name = body.tag_name\n db.commit()\n db.refresh(tag)\n return tag\nasync def find_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"\n get tag from database by name\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.9351503252983093 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Delete tag from database just for Administrator role\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Tag | None: tag object\n or None if the user have no permission to delete the tag or if no matching tag exists in the database\n \"\"\"\n tag = await find_tag(tag_name, db)\n if tag:", "score": 0.9323710799217224 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Args:\n tag_id: int: Find the tag in the database\n db: Session: Pass the database session to the function\n Returns:\n A tag object or none\n \"\"\"\n tag = db.query(Tag).filter(Tag.id == tag_id).first()\n return tag\nasync def delete_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"", "score": 0.9134595394134521 }, { "filename": "src/routes/users.py", "retrieved_chunk": " \"\"\"\n Take user to ban list\n Arguments:\n user_id (int): Get the username from the url path\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: banned user\n \"\"\"\n ban = await repository_users.ban_user(user_id, db)\n if ban is None:", "score": 0.9041299223899841 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.8997571468353271 } ]

[ { "filename": "src/routes/users.py", "retrieved_chunk": " \"\"\"\n Take user to ban list\n Arguments:\n user_id (int): Get the username from the url path\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: banned user\n \"\"\"\n ban = await repository_users.ban_user(user_id, db)\n if ban is None:", "score": 0.941662073135376 }, { "filename": "src/repository/users.py", "retrieved_chunk": " it returns None.\n Arguments:\n email (str): Pass in the email of the user we want to find\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User | None: A user object or None if the user is not found\n \"\"\"\n return db.query(User).filter_by(email=email).first()\nasync def create_user(body: UserModel, db: Session) -> User:\n \"\"\"", "score": 0.9395667910575867 }, { "filename": "src/repository/users.py", "retrieved_chunk": " url (str): Pass in the url of the avatar that we want to update\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object\n \"\"\"\n user = await get_user_by_email(email, db)\n user.avatar = url\n db.commit()\n return user\nasync def update_user(body: UserUpdate, user: User, db: Session) -> User | None:", "score": 0.9318844079971313 }, { "filename": "src/repository/images.py", "retrieved_chunk": " If there is an image it changes its description to what was provided in the body.\n Args:\n body (ImageModel): The ImageModel object to be created.\n image_id(int): The id of the desired Image object.\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object with the updated description\n \"\"\"\n image = await get_image_from_id(image_id, user, db)", "score": 0.9286895394325256 }, { "filename": "src/repository/users.py", "retrieved_chunk": " The create_user function creates a new user in the database.\n Arguments:\n body (UserModel): Pass in the UserModel object that is created from the request body\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object, which is the same as what we return from our get_user function\n \"\"\"\n g = Gravatar(body.email)\n new_user = User(**body.dict(), user_pic_url=g.get_image())\n db.add(new_user)", "score": 0.925501823425293 } ]

[ { "filename": "src/repository/tags.py", "retrieved_chunk": " Delete tag from database just for Administrator role\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Tag | None: tag object\n or None if the user have no permission to delete the tag or if no matching tag exists in the database\n \"\"\"\n tag = await find_tag(tag_name, db)\n if tag:", "score": 0.9487974047660828 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Args:\n tag_id: int: Find the tag in the database\n db: Session: Pass the database session to the function\n Returns:\n A tag object or none\n \"\"\"\n tag = db.query(Tag).filter(Tag.id == tag_id).first()\n return tag\nasync def delete_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"", "score": 0.9357045888900757 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Returns:\n Tag | None: tag object\n or None if no matching tag exists in the database\n \"\"\"\n tag = db.query(Tag).filter(Tag.tag_name == tag_name).first()\n return tag\nasync def find_tag_by_id(tag_id: int, db: Session) -> Tag | None:\n \"\"\"\n The find_tag_by_id function takes in a tag_id and db Session object,\n and returns the Tag object with that id. If no such tag exists, it returns None.", "score": 0.9249054789543152 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " tag.tag_name = body.tag_name\n db.commit()\n db.refresh(tag)\n return tag\nasync def find_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"\n get tag from database by name\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.9244964122772217 }, { "filename": "src/repository/images.py", "retrieved_chunk": " If there is an image it changes its description to what was provided in the body.\n Args:\n body (ImageModel): The ImageModel object to be created.\n image_id(int): The id of the desired Image object.\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object with the updated description\n \"\"\"\n image = await get_image_from_id(image_id, user, db)", "score": 0.9146806001663208 } ]

[ { "filename": "src/services/auth.py", "retrieved_chunk": " payload = cls.token_decode(token)\n if payload['scope'] == 'email_token':\n email = payload['sub']\n return email\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid scope for token')\nauth_service = Auth()", "score": 0.842845618724823 }, { "filename": "tests/test_unit_route_users.py", "retrieved_chunk": " assert response.status_code == status.HTTP_200_OK\n print(response.json())\n response = client.put(\"api/users/update_user_by_admin\")\n assert response.status_code == status.HTTP_401_UNAUTHORIZED\ndef test_ban_user(client, user, token):\n response = client.put(f\"api/users/ban_user/?user_id=1\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\n response = client.put(f\"api/users/ban_user/?user_id=100\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_404_NOT_FOUND", "score": 0.8239147067070007 }, { "filename": "tests/test_unit_route_images.py", "retrieved_chunk": " assert response.status_code == status.HTTP_404_NOT_FOUND\n response = client.patch(\"/api/images/description/{image_id}\", json={\"descri\": \"n\"},\n headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY\ndef test_update_description_image_by_user(client, token_user, image_user):\n response = client.patch(\"/api/images/description/3\", json={\n \"description\": \"description_description_description\",\n \"tags_text\": \"python\"}, headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_200_OK, response.text\n data = response.json()", "score": 0.8137333989143372 }, { "filename": "tests/test_unit_route_images.py", "retrieved_chunk": " response = client.delete(\"/api/images/{image_id}\", headers={\"Authorization\": f\"Bearer {token_moder}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\ndef test_remove_image_by_user(client, token_user, image_user):\n response = client.delete(\"/api/images/3\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\n response = client.delete(\"/api/images/100\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\n response = client.delete(\"/api/images/{image_id}\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\ndef test_create_image(client, token):", "score": 0.8086730241775513 }, { "filename": "tests/test_unit_route_auth.py", "retrieved_chunk": "def test_logout(client, token):\n response = client.post(\"api/auth/logout\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\ndef test_refresh_token(client, token):\n response = client.get(\"api/auth/refresh_token\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\n response = client.get(\"api/auth/refresh_token\")\n assert response.status_code == status.HTTP_401_UNAUTHORIZED", "score": 0.808468222618103 } ]

[ { "filename": "tests/test_unit_route_users.py", "retrieved_chunk": " assert response.status_code == status.HTTP_200_OK\n print(response.json())\n response = client.put(\"api/users/update_user_by_admin\")\n assert response.status_code == status.HTTP_401_UNAUTHORIZED\ndef test_ban_user(client, user, token):\n response = client.put(f\"api/users/ban_user/?user_id=1\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\n response = client.put(f\"api/users/ban_user/?user_id=100\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_404_NOT_FOUND", "score": 0.8292782306671143 }, { "filename": "tests/test_unit_route_auth.py", "retrieved_chunk": "def test_logout(client, token):\n response = client.post(\"api/auth/logout\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\ndef test_refresh_token(client, token):\n response = client.get(\"api/auth/refresh_token\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\n response = client.get(\"api/auth/refresh_token\")\n assert response.status_code == status.HTTP_401_UNAUTHORIZED", "score": 0.8154690265655518 }, { "filename": "tests/test_unit_route_images.py", "retrieved_chunk": " response = client.delete(\"/api/images/{image_id}\", headers={\"Authorization\": f\"Bearer {token_moder}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\ndef test_remove_image_by_user(client, token_user, image_user):\n response = client.delete(\"/api/images/3\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\n response = client.delete(\"/api/images/100\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\n response = client.delete(\"/api/images/{image_id}\", headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_403_FORBIDDEN\ndef test_create_image(client, token):", "score": 0.8134037256240845 }, { "filename": "tests/test_unit_route_users.py", "retrieved_chunk": " login = user['login']\n response = client.get(f\"api/users/user/{login}/\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_200_OK\n login = 'test_wrong_login'\n response = client.get(f\"api/users/user/{login}/\", headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_404_NOT_FOUND\ndef test_change_role(client, user, token):\n response = client.put(\"api/users/change_role\",\n json={\n \"id\": 1000,", "score": 0.8103269338607788 }, { "filename": "tests/test_unit_route_images.py", "retrieved_chunk": " assert response.status_code == status.HTTP_404_NOT_FOUND\n response = client.patch(\"/api/images/description/{image_id}\", json={\"descri\": \"n\"},\n headers={\"Authorization\": f\"Bearer {token}\"})\n assert response.status_code == status.HTTP_422_UNPROCESSABLE_ENTITY\ndef test_update_description_image_by_user(client, token_user, image_user):\n response = client.patch(\"/api/images/description/3\", json={\n \"description\": \"description_description_description\",\n \"tags_text\": \"python\"}, headers={\"Authorization\": f\"Bearer {token_user}\"})\n assert response.status_code == status.HTTP_200_OK, response.text\n data = response.json()", "score": 0.8076318502426147 } ]

[ { "filename": "src/repository/users.py", "retrieved_chunk": " db.commit()\n return user_to_update\n return None\nasync def change_role(body: UserChangeRole, user: User, db: Session) -> User | None:\n \"\"\"\n Logged-in admin can change role of any profile by ID.\n Arguments:\n body (UserChangeRole): A set of user new role\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.9395353198051453 }, { "filename": "src/repository/users.py", "retrieved_chunk": " url (str): Pass in the url of the avatar that we want to update\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object\n \"\"\"\n user = await get_user_by_email(email, db)\n user.avatar = url\n db.commit()\n return user\nasync def update_user(body: UserUpdate, user: User, db: Session) -> User | None:", "score": 0.9348841309547424 }, { "filename": "src/repository/users.py", "retrieved_chunk": " \"\"\"\n Updates user profile.\n Logged-in admin can update any profile.\n Arguments:\n body (UserUpdateAdmin): A set of user attributes to update\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User | None: A user object or None\n \"\"\"", "score": 0.9315599799156189 }, { "filename": "src/repository/users.py", "retrieved_chunk": " \"\"\"\n Updates user profile.\n Logged-in user can update his information.\n Arguments:\n body (UserUpdate): A set of user attributes to update\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User | None: A user object or None\n \"\"\"", "score": 0.9315235018730164 }, { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.9257270097732544 } ]

[ { "filename": "src/services/auth.py", "retrieved_chunk": " @classmethod\n async def decode_refresh_token(cls, refresh_token: str):\n \"\"\"\n The decode_refresh_token function is used to decode the refresh token.\n It takes a refresh_token as an argument and returns the email of the user if it's valid.\n If not, it raises an HTTPException with status code 401 (UNAUTHORIZED)\n and detail 'Could not validate credentials'.\n Arguments:\n refresh_token (str): Pass the refresh token to the function\n Returns:", "score": 0.9187365770339966 }, { "filename": "src/services/auth.py", "retrieved_chunk": " Arguments:\n token (str): Get the token from the request header\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n A user object if the token is valid\n \"\"\"\n payload = cls.token_decode(token)\n if payload.get(\"scope\") == \"access_token\":\n email = payload.get(\"sub\")\n if email is None:", "score": 0.9142378568649292 }, { "filename": "src/repository/users.py", "retrieved_chunk": " db.commit()\n db.refresh(new_user)\n return new_user\nasync def update_token(user: User, refresh_token: str | None, db: Session) -> None:\n \"\"\"\n The update_token function updates the refresh token for a user.\n Arguments:\n user (User): Pass the user object to the function\n refresh_token (str | None): Pass the refresh token to the update_token function\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.8969398736953735 }, { "filename": "src/services/auth.py", "retrieved_chunk": " return jwt.decode(token, cls.SECRET_KEY, algorithms=[cls.ALGORITHM])\n except JWTError:\n raise cls.credentials_exception\n @classmethod\n async def create_access_token(cls, data: dict, expires_delta: Optional[float] = None) -> dict:\n \"\"\"\n The create_access_token function creates a new access token for the user.\n The function takes in two arguments: data and expires_delta.\n Data is a dictionary that contains all of the information about the user,\n such as their username, email address, etc.", "score": 0.8963804841041565 }, { "filename": "src/repository/users.py", "retrieved_chunk": " return None\nasync def is_blacklisted_token(token: str, db: Session) -> bool:\n \"\"\"\n Function takes checks if a token is blacklisted.\n Arguments:\n token (str): token to be checked\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n bool\n \"\"\"", "score": 0.8958863019943237 } ]

[ { "filename": "src/routes/auth.py", "retrieved_chunk": " add access token to blacklist, and returns massage.\n Arguments:\n credentials (HTTPAuthorizationCredentials): Get the token from the request header\n db (Session): SQLAlchemy session object for accessing the database\n current_user (UserModel): the current user\n Returns:\n dict: JSON message\n \"\"\"\n token = credentials.credentials\n await repository_users.add_to_blacklist(token, db)", "score": 0.9398124814033508 }, { "filename": "src/repository/users.py", "retrieved_chunk": " \"\"\"\n Updates user profile.\n Logged-in user can update his information.\n Arguments:\n body (UserUpdate): A set of user attributes to update\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User | None: A user object or None\n \"\"\"", "score": 0.9273790717124939 }, { "filename": "src/repository/users.py", "retrieved_chunk": " \"\"\"\n Updates user profile.\n Logged-in admin can update any profile.\n Arguments:\n body (UserUpdateAdmin): A set of user attributes to update\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User | None: A user object or None\n \"\"\"", "score": 0.9250336289405823 }, { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.9233714938163757 }, { "filename": "src/repository/users.py", "retrieved_chunk": " url (str): Pass in the url of the avatar that we want to update\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object\n \"\"\"\n user = await get_user_by_email(email, db)\n user.avatar = url\n db.commit()\n return user\nasync def update_user(body: UserUpdate, user: User, db: Session) -> User | None:", "score": 0.9217485189437866 } ]

[ { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.9159939885139465 }, { "filename": "src/repository/users.py", "retrieved_chunk": " The create_user function creates a new user in the database.\n Arguments:\n body (UserModel): Pass in the UserModel object that is created from the request body\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object, which is the same as what we return from our get_user function\n \"\"\"\n g = Gravatar(body.email)\n new_user = User(**body.dict(), user_pic_url=g.get_image())\n db.add(new_user)", "score": 0.9158639311790466 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.911575436592102 }, { "filename": "src/repository/users.py", "retrieved_chunk": " url (str): Pass in the url of the avatar that we want to update\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object\n \"\"\"\n user = await get_user_by_email(email, db)\n user.avatar = url\n db.commit()\n return user\nasync def update_user(body: UserUpdate, user: User, db: Session) -> User | None:", "score": 0.9061883091926575 }, { "filename": "src/routes/images.py", "retrieved_chunk": " tags_text (str): Get the tags from the request body\n image_file (UploadFile): Get the file from the request\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: the Image object\n \"\"\"\n try:\n body = ImageModel(description=description, tags_text=tags_text)\n except ValidationError:", "score": 0.9042580723762512 } ]

[ { "filename": "src/repository/images.py", "retrieved_chunk": " body (ImageModel): The ImageModel object to be created.\n image_url(str): Pass the image url to the database\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The image object\n \"\"\"\n image = Image(description=body.description, user=user, image_url=image_url, tags=await create_tags(body.tags_text, db))\n db.add(image)\n db.commit()", "score": 0.8913556933403015 }, { "filename": "src/repository/users.py", "retrieved_chunk": " The create_user function creates a new user in the database.\n Arguments:\n body (UserModel): Pass in the UserModel object that is created from the request body\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: A user object, which is the same as what we return from our get_user function\n \"\"\"\n g = Gravatar(body.email)\n new_user = User(**body.dict(), user_pic_url=g.get_image())\n db.add(new_user)", "score": 0.8726873397827148 }, { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.8722316026687622 }, { "filename": "src/routes/images.py", "retrieved_chunk": " image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n image/png: streamingresponse\n \"\"\"\n image = await repository_images.get_image(image_id, current_user, db)\n if image is None:\n raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=\"Not Found\")\n qr_code = await CloudImage.create_qr_code_image(image.image_url)", "score": 0.8652596473693848 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.8629024028778076 } ]

[ { "filename": "learning/nets/fc_2layers_64units.py", "retrieved_chunk": "import numpy as np\nimport torch\ndef build_net(input_dict, activation):\n layer_sizes = [64, 32]\n input_dim = np.sum([np.prod(curr_input.shape) for curr_input in input_dict.values()])\n in_size = input_dim\n layers = []\n for out_size in layer_sizes:\n curr_layer = torch.nn.Linear(in_size, out_size)\n torch.nn.init.zeros_(curr_layer.bias)", "score": 0.8394551277160645 }, { "filename": "learning/nets/fc_2layers_1024units.py", "retrieved_chunk": "import numpy as np\nimport torch\ndef build_net(input_dict, activation):\n layer_sizes = [1024, 512]\n input_dim = np.sum([np.prod(curr_input.shape) for curr_input in input_dict.values()])\n in_size = input_dim\n layers = []\n for out_size in layer_sizes:\n curr_layer = torch.nn.Linear(in_size, out_size)\n torch.nn.init.zeros_(curr_layer.bias)", "score": 0.8382407426834106 }, { "filename": "learning/nets/fc_2layers_128units.py", "retrieved_chunk": "import numpy as np\nimport torch\ndef build_net(input_dict, activation):\n layer_sizes = [128, 64]\n input_dim = np.sum([np.prod(curr_input.shape) for curr_input in input_dict.values()])\n in_size = input_dim\n layers = []\n for out_size in layer_sizes:\n curr_layer = torch.nn.Linear(in_size, out_size)\n torch.nn.init.zeros_(curr_layer.bias)", "score": 0.8377641439437866 }, { "filename": "learning/nets/fc_1layers_32units.py", "retrieved_chunk": "import numpy as np\nimport torch\ndef build_net(input_dict, activation):\n layer_sizes = [32]\n input_dim = np.sum([np.prod(curr_input.shape) for curr_input in input_dict.values()])\n in_size = input_dim\n layers = []\n for out_size in layer_sizes:\n curr_layer = torch.nn.Linear(in_size, out_size)\n torch.nn.init.zeros_(curr_layer.bias)", "score": 0.836158275604248 }, { "filename": "learning/nets/fc_1layers_16units.py", "retrieved_chunk": "import numpy as np\nimport torch\ndef build_net(input_dict, activation):\n layer_sizes = [16]\n input_dim = np.sum([np.prod(curr_input.shape) for curr_input in input_dict.values()])\n in_size = input_dim\n layers = []\n for out_size in layer_sizes:\n curr_layer = torch.nn.Linear(in_size, out_size)\n torch.nn.init.zeros_(curr_layer.bias)", "score": 0.8329330682754517 } ]

[ { "filename": "src/routes/users.py", "retrieved_chunk": " \"\"\"\n Take user to ban list\n Arguments:\n user_id (int): Get the username from the url path\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: banned user\n \"\"\"\n ban = await repository_users.ban_user(user_id, db)\n if ban is None:", "score": 0.931597113609314 }, { "filename": "src/routes/images.py", "retrieved_chunk": " tags_text (str): Get the tags from the request body\n image_file (UploadFile): Get the file from the request\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: the Image object\n \"\"\"\n try:\n body = ImageModel(description=description, tags_text=tags_text)\n except ValidationError:", "score": 0.907106876373291 }, { "filename": "src/routes/images.py", "retrieved_chunk": " It also takes in a current_user and db objects as dependencies.\n Arguments:\n body (ImageModel): Get the new description for the image\n image_id (int): Get the image id from the path\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n Image: The updated image\n \"\"\"\n image = await repository_images.change_description(body, image_id, current_user, db)", "score": 0.9068617224693298 }, { "filename": "src/routes/images.py", "retrieved_chunk": " The remove_image function removes an image from the database.\n Arguments:\n image_id (int): Specify the id of the image to be removed\n current_user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None: The image that was removed\n \"\"\"\n image = await repository_images.remove(image_id, current_user, db)\n if image is None:", "score": 0.9064694046974182 }, { "filename": "src/repository/users.py", "retrieved_chunk": " return None\nasync def is_blacklisted_token(token: str, db: Session) -> bool:\n \"\"\"\n Function takes checks if a token is blacklisted.\n Arguments:\n token (str): token to be checked\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n bool\n \"\"\"", "score": 0.9050735831260681 } ]

[ { "filename": "tests/test_unit_route_comments.py", "retrieved_chunk": " assert data[0][\"id\"] == 1\ndef test_update_comment(client, token):\n response = client.put(\n \"api/comments/1\", json={\"comment_text\": \"NEW Test text for comment\"},\n headers={\"Authorization\": f\"Bearer {token}\"}\n )\n assert response.status_code == 200, response.text\n body_data = response.json()\n assert body_data == {\n \"id\": 1,", "score": 0.8539086580276489 }, { "filename": "src/routes/tags.py", "retrieved_chunk": " tag_name (str): tag name to found\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n None\n \"\"\"\n tag = await repository_tag.delete_tag(tag_name, db)\n if tag is None:\n raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail='Not found')\n return None", "score": 0.8335881233215332 }, { "filename": "src/routes/users.py", "retrieved_chunk": " user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: object after the change operation\n \"\"\"\n user = await repository_users.update_user_by_admin(body, user, db)\n if user is None:\n raise HTTPException(\n status_code=status.HTTP_404_NOT_FOUND, detail=\"NOT_FOUND\")\n return user", "score": 0.8231324553489685 }, { "filename": "tests/test_route_main.py", "retrieved_chunk": "from fastapi import status\ndef test_root(client):\n response = client.get(\"/\")\n assert response.status_code == status.HTTP_200_OK\n data = response.json()\n assert data[\"message\"] == \"Welcome to the FAST API from team 6\"\ndef test_healthchecker(client):\n response = client.get(\"/api/healthchecker\")\n assert response.status_code == status.HTTP_200_OK\n data = response.json()", "score": 0.8137361407279968 }, { "filename": "src/services/auth.py", "retrieved_chunk": " The email of the user that is associated with the refresh token\n \"\"\"\n payload = cls.token_decode(refresh_token)\n if payload['scope'] == 'refresh_token':\n email = payload['sub']\n return email\n raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail='Invalid scope for token')\n @classmethod\n def create_email_token(cls, data: dict):\n \"\"\"", "score": 0.8118370771408081 } ]

[ { "filename": "learning/base_agent.py", "retrieved_chunk": " self._discount = config[\"discount\"]\n self._steps_per_iter = config[\"steps_per_iter\"]\n self._iters_per_output = config[\"iters_per_output\"]\n self._test_episodes = config[\"test_episodes\"]\n self._normalizer_samples = config.get(\"normalizer_samples\", np.inf)\n return\n @abc.abstractmethod\n def _build_model(self, config):\n return\n def _build_normalizers(self):", "score": 0.8665158748626709 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " return\n def _load_params(self, config):\n super()._load_params(config)\n self._batch_size = config[\"batch_size\"]\n self._critic_update_epoch = config[\"critic_update_epoch\"]\n self._norm_adv_clip = config[\"norm_adv_clip\"]\n self._action_bound_weight = config[\"action_bound_weight\"]\n return\n def _build_model(self, config):\n model_config = config[\"model\"]", "score": 0.8627020120620728 }, { "filename": "a1/bc_agent.py", "retrieved_chunk": " return\n def _load_params(self, config):\n super()._load_params(config)\n buffer_size = config[\"exp_buffer_size\"]\n self._exp_buffer_length = max(buffer_size, self._steps_per_iter)\n self._batch_size = config[\"batch_size\"]\n self._update_epochs = config[\"update_epochs\"]\n return\n def _build_model(self, config):\n model_config = config[\"model\"]", "score": 0.852508544921875 }, { "filename": "a2/cem_agent.py", "retrieved_chunk": " self._best_return = None\n self._best_params = None\n return\n def _load_params(self, config):\n super()._load_params(config)\n self._population_size = config[\"population_size\"]\n self._elite_ratio = config[\"elite_ratio\"]\n self._eps_per_candidate = config[\"eps_per_candidate\"]\n self._min_param_std = config[\"min_param_std\"]\n return", "score": 0.8179181814193726 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " self._model = pg_model.PGModel(model_config, self._env)\n return\n def _get_exp_buffer_length(self):\n return self._steps_per_iter\n def _build_exp_buffer(self, config):\n super()._build_exp_buffer(config)\n buffer_length = self._get_exp_buffer_length()\n tar_val_buffer = torch.zeros([buffer_length], device=self._device, dtype=torch.float)\n self._exp_buffer.add_buffer(\"tar_val\", tar_val_buffer)\n adv_buffer = torch.zeros([buffer_length], device=self._device, dtype=torch.float)", "score": 0.8087879419326782 } ]

[ { "filename": "a1/bc_agent.py", "retrieved_chunk": " batch = self._exp_buffer.sample(batch_size)\n loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n num_steps = self._update_epochs * num_batches\n torch_util.scale_torch_dict(1.0 / num_steps, train_info)\n return train_info ", "score": 0.9750992059707642 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " train_info = dict()\n for e in range(self._critic_update_epoch): \n for b in range(num_batches):\n batch = self._exp_buffer.sample(batch_size)\n critic_info = self._update_critic(batch) \n torch_util.add_torch_dict(critic_info, train_info)\n torch_util.scale_torch_dict(1.0 / num_batches, train_info)\n actor_batch = {\n \"norm_obs\": self._exp_buffer.get_data(\"norm_obs\"),\n \"norm_action\": self._exp_buffer.get_data(\"norm_action\"),", "score": 0.8914086818695068 }, { "filename": "learning/dqn_model.py", "retrieved_chunk": " num_actions = a_space.n\n self._q_layers, _ = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n layers_out_size = torch_util.calc_layers_out_size(self._q_layers)\n self._q_out = torch.nn.Linear(layers_out_size, num_actions)\n torch.nn.init.uniform_(self._q_out.weight, -q_init_output_scale, q_init_output_scale)\n torch.nn.init.zeros_(self._q_out.bias)\n return\n def _build_q_input_dict(self, env):\n obs_space = env.get_obs_space()", "score": 0.8421242237091064 }, { "filename": "learning/distribution_gaussian_diag.py", "retrieved_chunk": " self._std_type = std_type\n self._build_params(in_size, out_size, init_std, init_output_scale)\n return\n def _build_params(self, in_size, out_size, init_std, init_output_scale):\n self._mean_net = torch.nn.Linear(in_size, out_size)\n torch.nn.init.uniform_(self._mean_net.weight, -init_output_scale, init_output_scale)\n torch.nn.init.zeros_(self._mean_net.bias)\n logstd = np.log(init_std)\n if (self._std_type == StdType.FIXED):\n self._logstd_net = torch.nn.Parameter(torch.zeros(out_size, requires_grad=False, dtype=torch.float32), requires_grad=False)", "score": 0.8214941024780273 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " def _build_optimizer(self, config):\n actor_lr = float(config[\"actor_learning_rate\"])\n critic_lr = float(config[\"critic_learning_rate\"])\n actor_params = list(self._model._actor_layers.parameters())+list(self._model._action_dist.parameters())\n actor_params_grad = [p for p in actor_params if p.requires_grad]\n self._actor_optimizer = torch.optim.SGD(actor_params_grad, actor_lr, momentum=0.9)\n critic_params = list(self._model._critic_layers.parameters())+list(self._model._critic_out.parameters())\n critic_params_grad = [p for p in critic_params if p.requires_grad]\n self._critic_optimizer = torch.optim.SGD(critic_params_grad, critic_lr, momentum=0.9)\n return", "score": 0.8207566738128662 } ]

[ { "filename": "a3/dqn_agent.py", "retrieved_chunk": " self._tar_net_update_iters = config[\"tar_net_update_iters\"]\n self._exp_anneal_samples = config.get(\"exp_anneal_samples\", np.inf)\n self._exp_prob_beg = config.get(\"exp_prob_beg\", 1.0)\n self._exp_prob_end = config.get(\"exp_prob_end\", 1.0)\n return\n def _build_model(self, config):\n model_config = config[\"model\"]\n self._model = dqn_model.DQNModel(model_config, self._env)\n self._tar_model = dqn_model.DQNModel(model_config, self._env)\n for param in self._tar_model.parameters():", "score": 0.7301499843597412 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " test_return = test_info[\"mean_return\"]\n test_ep_len = test_info[\"mean_ep_len\"]\n test_eps = test_info[\"episodes\"]\n self._logger.log(\"Test_Return\", test_return, collection=\"0_Main\")\n self._logger.log(\"Test_Episode_Length\", test_ep_len, collection=\"0_Main\", quiet=True)\n self._logger.log(\"Test_Episodes\", test_eps, collection=\"1_Info\", quiet=True)\n train_return = train_info.pop(\"mean_return\")\n train_ep_len = train_info.pop(\"mean_ep_len\")\n train_eps = train_info.pop(\"episodes\")\n self._logger.log(\"Train_Return\", train_return, collection=\"0_Main\")", "score": 0.7220066785812378 }, { "filename": "envs/atari_env.py", "retrieved_chunk": " done = self._compute_done(terminated, truncated) \n return self._curr_obs, reward, done, self._curr_info \n def _build_atari_env(self, config, visualize):\n env_name = config[\"env_name\"]\n max_timesteps = config.get(\"max_timesteps\", None)\n assert(env_name.startswith(\"atari_\"))\n env_name = env_name[6:]\n env_name = env_name + \"NoFrameskip-v4\"\n atari_env = atari_wrappers.make_atari(env_name, \n max_episode_steps=max_timesteps,", "score": 0.7192939519882202 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " self._discount = config[\"discount\"]\n self._steps_per_iter = config[\"steps_per_iter\"]\n self._iters_per_output = config[\"iters_per_output\"]\n self._test_episodes = config[\"test_episodes\"]\n self._normalizer_samples = config.get(\"normalizer_samples\", np.inf)\n return\n @abc.abstractmethod\n def _build_model(self, config):\n return\n def _build_normalizers(self):", "score": 0.7168712615966797 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " violation_min = torch.clamp_max(norm_a_dist.mode - bound_min, 0.0)\n violation_max = torch.clamp_min(norm_a_dist.mode - bound_max, 0)\n violation = torch.sum(torch.square(violation_min), dim=-1) \\\n + torch.sum(torch.square(violation_max), dim=-1)\n loss = violation\n return loss\n def _output_train_model(self, iter, out_model_file, int_output_dir):\n self.save(out_model_file)\n if (int_output_dir != \"\"):\n int_model_file = os.path.join(int_output_dir, \"model_{:010d}.pt\".format(iter))", "score": 0.7108110189437866 } ]

[ { "filename": "src/routes/users.py", "retrieved_chunk": " user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: object after the change operation\n \"\"\"\n user = await repository_users.update_user_by_admin(body, user, db)\n if user is None:\n raise HTTPException(\n status_code=status.HTTP_404_NOT_FOUND, detail=\"NOT_FOUND\")\n return user", "score": 0.8974005579948425 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Returns:\n Tag | None: tag object\n or None if no matching tag exists in the database\n \"\"\"\n tag = db.query(Tag).filter(Tag.tag_name == tag_name).first()\n return tag\nasync def find_tag_by_id(tag_id: int, db: Session) -> Tag | None:\n \"\"\"\n The find_tag_by_id function takes in a tag_id and db Session object,\n and returns the Tag object with that id. If no such tag exists, it returns None.", "score": 0.8952854871749878 }, { "filename": "src/routes/users.py", "retrieved_chunk": " body (UserUpdate): object with new role\n user (User): the current user\n db (Session): SQLAlchemy session object for accessing the database\n Returns:\n User: object after the change operation\n \"\"\"\n user = await repository_users.update_user(body, user, db)\n if user is None:\n raise HTTPException(\n status_code=status.HTTP_404_NOT_FOUND, detail=\"NOT_FOUND\")", "score": 0.8883751034736633 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " Args:\n tag_id: int: Find the tag in the database\n db: Session: Pass the database session to the function\n Returns:\n A tag object or none\n \"\"\"\n tag = db.query(Tag).filter(Tag.id == tag_id).first()\n return tag\nasync def delete_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"", "score": 0.8855173587799072 }, { "filename": "src/repository/tags.py", "retrieved_chunk": " tag.tag_name = body.tag_name\n db.commit()\n db.refresh(tag)\n return tag\nasync def find_tag(tag_name: str, db: Session) -> Tag | None:\n \"\"\"\n get tag from database by name\n Arguments:\n tag_name (str): name of tag to find\n db (Session): SQLAlchemy session object for accessing the database", "score": 0.8830963373184204 } ]

[ { "filename": "a1/bc_agent.py", "retrieved_chunk": " return\n def _load_params(self, config):\n super()._load_params(config)\n buffer_size = config[\"exp_buffer_size\"]\n self._exp_buffer_length = max(buffer_size, self._steps_per_iter)\n self._batch_size = config[\"batch_size\"]\n self._update_epochs = config[\"update_epochs\"]\n return\n def _build_model(self, config):\n model_config = config[\"model\"]", "score": 0.8888322114944458 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " self._tar_net_update_iters = config[\"tar_net_update_iters\"]\n self._exp_anneal_samples = config.get(\"exp_anneal_samples\", np.inf)\n self._exp_prob_beg = config.get(\"exp_prob_beg\", 1.0)\n self._exp_prob_end = config.get(\"exp_prob_end\", 1.0)\n return\n def _build_model(self, config):\n model_config = config[\"model\"]\n self._model = dqn_model.DQNModel(model_config, self._env)\n self._tar_model = dqn_model.DQNModel(model_config, self._env)\n for param in self._tar_model.parameters():", "score": 0.8699610233306885 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " self._discount = config[\"discount\"]\n self._steps_per_iter = config[\"steps_per_iter\"]\n self._iters_per_output = config[\"iters_per_output\"]\n self._test_episodes = config[\"test_episodes\"]\n self._normalizer_samples = config.get(\"normalizer_samples\", np.inf)\n return\n @abc.abstractmethod\n def _build_model(self, config):\n return\n def _build_normalizers(self):", "score": 0.8677179217338562 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " super().__init__(config, env, device)\n return\n def _load_params(self, config):\n super()._load_params(config)\n buffer_size = config[\"exp_buffer_size\"]\n self._exp_buffer_length = int(buffer_size)\n self._exp_buffer_length = max(self._exp_buffer_length, self._steps_per_iter)\n self._updates_per_iter = config[\"updates_per_iter\"]\n self._batch_size = config[\"batch_size\"]\n self._init_samples = config[\"init_samples\"]", "score": 0.8488031625747681 }, { "filename": "a2/cem_agent.py", "retrieved_chunk": " self._best_return = None\n self._best_params = None\n return\n def _load_params(self, config):\n super()._load_params(config)\n self._population_size = config[\"population_size\"]\n self._elite_ratio = config[\"elite_ratio\"]\n self._eps_per_candidate = config[\"eps_per_candidate\"]\n self._min_param_std = config[\"min_param_std\"]\n return", "score": 0.8399447202682495 } ]

[ { "filename": "a3/dqn_agent.py", "retrieved_chunk": " super().__init__(config, env, device)\n return\n def _load_params(self, config):\n super()._load_params(config)\n buffer_size = config[\"exp_buffer_size\"]\n self._exp_buffer_length = int(buffer_size)\n self._exp_buffer_length = max(self._exp_buffer_length, self._steps_per_iter)\n self._updates_per_iter = config[\"updates_per_iter\"]\n self._batch_size = config[\"batch_size\"]\n self._init_samples = config[\"init_samples\"]", "score": 0.9428088068962097 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " return\n def _load_params(self, config):\n super()._load_params(config)\n self._batch_size = config[\"batch_size\"]\n self._critic_update_epoch = config[\"critic_update_epoch\"]\n self._norm_adv_clip = config[\"norm_adv_clip\"]\n self._action_bound_weight = config[\"action_bound_weight\"]\n return\n def _build_model(self, config):\n model_config = config[\"model\"]", "score": 0.8951736688613892 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " self._discount = config[\"discount\"]\n self._steps_per_iter = config[\"steps_per_iter\"]\n self._iters_per_output = config[\"iters_per_output\"]\n self._test_episodes = config[\"test_episodes\"]\n self._normalizer_samples = config.get(\"normalizer_samples\", np.inf)\n return\n @abc.abstractmethod\n def _build_model(self, config):\n return\n def _build_normalizers(self):", "score": 0.8638794422149658 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " return a_norm\n def _build_optimizer(self, config):\n lr = float(config[\"learning_rate\"])\n params = list(self.parameters())\n params = [p for p in params if p.requires_grad]\n self._optimizer = torch.optim.SGD(params, lr, momentum=0.9)\n return\n def _build_exp_buffer(self, config):\n buffer_length = self._get_exp_buffer_length()\n self._exp_buffer = experience_buffer.ExperienceBuffer(buffer_length=buffer_length,", "score": 0.8571693897247314 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " self._tar_net_update_iters = config[\"tar_net_update_iters\"]\n self._exp_anneal_samples = config.get(\"exp_anneal_samples\", np.inf)\n self._exp_prob_beg = config.get(\"exp_prob_beg\", 1.0)\n self._exp_prob_end = config.get(\"exp_prob_end\", 1.0)\n return\n def _build_model(self, config):\n model_config = config[\"model\"]\n self._model = dqn_model.DQNModel(model_config, self._env)\n self._tar_model = dqn_model.DQNModel(model_config, self._env)\n for param in self._tar_model.parameters():", "score": 0.8552643060684204 } ]

[ { "filename": "learning/expert_agent.py", "retrieved_chunk": "import learning.base_agent as base_agent\nimport learning.expert_model as expert_model\nclass ExpertAgent(base_agent.BaseAgent):\n NAME = \"Expert\"\n def __init__(self, config, env, device):\n super().__init__(config, env, device)\n return\n def _build_model(self, config):\n model_config = config[\"model\"]\n self._model = expert_model.ExpertModel(model_config, self._env)", "score": 0.8723531365394592 }, { "filename": "learning/bc_model.py", "retrieved_chunk": " return\n def _build_actor(self, config, env):\n net_name = config[\"actor_net\"]\n input_dict = self._build_actor_input_dict(env)\n self._actor_layers, layers_info = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n self._action_dist = self._build_action_distribution(config, env, self._actor_layers)\n return\n def _build_actor_input_dict(self, env):\n obs_space = env.get_obs_space()", "score": 0.812663733959198 }, { "filename": "learning/pg_model.py", "retrieved_chunk": " return\n def _build_actor(self, config, env):\n net_name = config[\"actor_net\"]\n input_dict = self._build_actor_input_dict(env)\n self._actor_layers, layers_info = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n self._action_dist = self._build_action_distribution(config, env, self._actor_layers)\n return\n def _build_critic(self, config, env):\n net_name = config[\"critic_net\"]", "score": 0.8115254044532776 }, { "filename": "learning/expert_model.py", "retrieved_chunk": " return\n def _build_actor(self, config, env):\n net_name = config[\"actor_net\"]\n input_dict = self._build_actor_input_dict(env)\n self._actor_layers, layers_info = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n self._action_dist = self._build_action_distribution(config, env, self._actor_layers)\n return\n def _build_critic(self, config, env):\n net_name = config[\"critic_net\"]", "score": 0.8115254044532776 }, { "filename": "learning/cem_model.py", "retrieved_chunk": " a_dist = self._action_dist(h)\n return a_dist\n def _build_nets(self, config, env):\n self._build_actor(config, env)\n return\n def _build_actor(self, config, env):\n net_name = config[\"actor_net\"]\n input_dict = self._build_actor_input_dict(env)\n self._actor_layers, layers_info = net_builder.build_net(net_name, input_dict,\n activation=self._activation)", "score": 0.8042269945144653 } ]

[ { "filename": "learning/base_agent.py", "retrieved_chunk": " self._curr_obs, self._curr_info = self._env.reset()\n test_info = self._rollout_test(num_episodes)\n return test_info\n def get_action_size(self):\n a_space = self._env.get_action_space()\n if (isinstance(a_space, gym.spaces.Box)):\n a_size = np.prod(a_space.shape)\n elif (isinstance(a_space, gym.spaces.Discrete)):\n a_size = 1\n else:", "score": 0.8519859313964844 }, { "filename": "envs/atari_env.py", "retrieved_chunk": " return obs_space\n def get_action_space(self):\n a_space = self._env.action_space\n a_space._shape = (1,)\n return a_space\n def get_reward_bounds(self):\n return (-1.0, 1.0)", "score": 0.8474267721176147 }, { "filename": "envs/env_dm.py", "retrieved_chunk": " else:\n done = torch.tensor([base_env.DoneFlags.NULL.value], device=self._device)\n return done\n def get_action_space(self):\n action_spec = self._env.action_spec()\n if (isinstance(action_spec, dm_env.specs.BoundedArray)):\n low = action_spec.minimum\n high = action_spec.maximum\n action_space = gym.spaces.Box(low=low, high=high, shape=low.shape)\n else:", "score": 0.8380389213562012 }, { "filename": "envs/atari_wrappers.py", "retrieved_chunk": " def _get_ob(self):\n assert len(self.frames) == self.k\n return LazyFrames(list(self.frames))\nclass ScaledFloatFrame(gym.ObservationWrapper):\n def __init__(self, env):\n gym.ObservationWrapper.__init__(self, env)\n self.observation_space = gym.spaces.Box(low=0, high=1, shape=env.observation_space.shape, dtype=np.float32)\n def observation(self, observation):\n # careful! This undoes the memory optimization, use\n # with smaller replay buffers only.", "score": 0.8320101499557495 }, { "filename": "envs/atari_wrappers.py", "retrieved_chunk": " \"\"\"Return only every `skip`-th frame\"\"\"\n gym.Wrapper.__init__(self, env)\n # most recent raw observations (for max pooling across time steps)\n self._obs_buffer = np.zeros((2,)+env.observation_space.shape, dtype=np.uint8)\n self._skip = skip\n def step(self, action):\n \"\"\"Repeat action, sum reward, and max over last observations.\"\"\"\n total_reward = 0.0\n done = None\n for i in range(self._skip):", "score": 0.8297033905982971 } ]

[ { "filename": "a2/pg_agent.py", "retrieved_chunk": " return\n def _load_params(self, config):\n super()._load_params(config)\n self._batch_size = config[\"batch_size\"]\n self._critic_update_epoch = config[\"critic_update_epoch\"]\n self._norm_adv_clip = config[\"norm_adv_clip\"]\n self._action_bound_weight = config[\"action_bound_weight\"]\n return\n def _build_model(self, config):\n model_config = config[\"model\"]", "score": 0.8559839725494385 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " return a_norm\n def _build_optimizer(self, config):\n lr = float(config[\"learning_rate\"])\n params = list(self.parameters())\n params = [p for p in params if p.requires_grad]\n self._optimizer = torch.optim.SGD(params, lr, momentum=0.9)\n return\n def _build_exp_buffer(self, config):\n buffer_length = self._get_exp_buffer_length()\n self._exp_buffer = experience_buffer.ExperienceBuffer(buffer_length=buffer_length,", "score": 0.8523795008659363 }, { "filename": "learning/distribution_gaussian_diag.py", "retrieved_chunk": " self._std_type = std_type\n self._build_params(in_size, out_size, init_std, init_output_scale)\n return\n def _build_params(self, in_size, out_size, init_std, init_output_scale):\n self._mean_net = torch.nn.Linear(in_size, out_size)\n torch.nn.init.uniform_(self._mean_net.weight, -init_output_scale, init_output_scale)\n torch.nn.init.zeros_(self._mean_net.bias)\n logstd = np.log(init_std)\n if (self._std_type == StdType.FIXED):\n self._logstd_net = torch.nn.Parameter(torch.zeros(out_size, requires_grad=False, dtype=torch.float32), requires_grad=False)", "score": 0.8389265537261963 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " self._tar_net_update_iters = config[\"tar_net_update_iters\"]\n self._exp_anneal_samples = config.get(\"exp_anneal_samples\", np.inf)\n self._exp_prob_beg = config.get(\"exp_prob_beg\", 1.0)\n self._exp_prob_end = config.get(\"exp_prob_end\", 1.0)\n return\n def _build_model(self, config):\n model_config = config[\"model\"]\n self._model = dqn_model.DQNModel(model_config, self._env)\n self._tar_model = dqn_model.DQNModel(model_config, self._env)\n for param in self._tar_model.parameters():", "score": 0.8388991355895996 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " self._model = pg_model.PGModel(model_config, self._env)\n return\n def _get_exp_buffer_length(self):\n return self._steps_per_iter\n def _build_exp_buffer(self, config):\n super()._build_exp_buffer(config)\n buffer_length = self._get_exp_buffer_length()\n tar_val_buffer = torch.zeros([buffer_length], device=self._device, dtype=torch.float)\n self._exp_buffer.add_buffer(\"tar_val\", tar_val_buffer)\n adv_buffer = torch.zeros([buffer_length], device=self._device, dtype=torch.float)", "score": 0.8268693685531616 } ]

[ { "filename": "a3/dqn_agent.py", "retrieved_chunk": " loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n torch_util.scale_torch_dict(1.0 / self._updates_per_iter, train_info)\n if (self._iter % self._tar_net_update_iters == 0):\n self._sync_tar_model()\n return train_info", "score": 0.9533495903015137 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " train_info = dict()\n for e in range(self._critic_update_epoch): \n for b in range(num_batches):\n batch = self._exp_buffer.sample(batch_size)\n critic_info = self._update_critic(batch) \n torch_util.add_torch_dict(critic_info, train_info)\n torch_util.scale_torch_dict(1.0 / num_batches, train_info)\n actor_batch = {\n \"norm_obs\": self._exp_buffer.get_data(\"norm_obs\"),\n \"norm_action\": self._exp_buffer.get_data(\"norm_action\"),", "score": 0.8892697095870972 }, { "filename": "learning/dqn_model.py", "retrieved_chunk": " num_actions = a_space.n\n self._q_layers, _ = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n layers_out_size = torch_util.calc_layers_out_size(self._q_layers)\n self._q_out = torch.nn.Linear(layers_out_size, num_actions)\n torch.nn.init.uniform_(self._q_out.weight, -q_init_output_scale, q_init_output_scale)\n torch.nn.init.zeros_(self._q_out.bias)\n return\n def _build_q_input_dict(self, env):\n obs_space = env.get_obs_space()", "score": 0.847663402557373 }, { "filename": "a2/pg_agent.py", "retrieved_chunk": " info = {\n \"adv_mean\": adv_mean,\n \"adv_std\": adv_std\n }\n return info\n def _update_model(self):\n self.train()\n num_samples = self._exp_buffer.get_sample_count()\n batch_size = self._batch_size \n num_batches = int(np.ceil(float(num_samples) / batch_size))", "score": 0.8296865820884705 }, { "filename": "learning/pg_model.py", "retrieved_chunk": " input_dict = self._build_critic_input_dict(env)\n self._critic_layers, layers_info = net_builder.build_net(net_name, input_dict,\n activation=self._activation)\n layers_out_size = torch_util.calc_layers_out_size(self._critic_layers)\n self._critic_out = torch.nn.Linear(layers_out_size, 1)\n torch.nn.init.zeros_(self._critic_out.bias)\n return\n def _build_actor_input_dict(self, env):\n obs_space = env.get_obs_space()\n input_dict = {\"obs\": obs_space}", "score": 0.8209333419799805 } ]

[ { "filename": "a1/bc_agent.py", "retrieved_chunk": " batch = self._exp_buffer.sample(batch_size)\n loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n num_steps = self._update_epochs * num_batches\n torch_util.scale_torch_dict(1.0 / num_steps, train_info)\n return train_info ", "score": 0.8854935169219971 }, { "filename": "a1/bc_agent.py", "retrieved_chunk": " self._exp_buffer.record(\"expert_a\", action_info[\"expert_a\"])\n return\n def _update_model(self):\n self.train()\n num_samples = self._exp_buffer.get_sample_count()\n batch_size = self._batch_size \n num_batches = int(np.ceil(float(num_samples) / batch_size))\n train_info = dict()\n for i in range(self._update_epochs):\n for b in range(num_batches):", "score": 0.8813683986663818 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n torch_util.scale_torch_dict(1.0 / self._updates_per_iter, train_info)\n if (self._iter % self._tar_net_update_iters == 0):\n self._sync_tar_model()\n return train_info", "score": 0.8617225289344788 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " def _collect_init_samples(self, samples):\n self.eval()\n self.set_mode(base_agent.AgentMode.TRAIN)\n self._rollout_train(samples)\n return\n def _update_model(self):\n self.train()\n train_info = dict()\n for i in range(self._updates_per_iter):\n batch = self._exp_buffer.sample(self._batch_size)", "score": 0.8214281797409058 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " self._init_train()\n test_info = None\n while self._sample_count < max_samples:\n train_info = self._train_iter()\n output_iter = (self._iter % self._iters_per_output == 0)\n if (output_iter):\n test_info = self.test_model(self._test_episodes)\n self._sample_count = self._update_sample_count()\n self._log_train_info(train_info, test_info, start_time) \n self._logger.print_log()", "score": 0.8206831216812134 } ]

[ { "filename": "a1/bc_agent.py", "retrieved_chunk": " self._exp_buffer.record(\"expert_a\", action_info[\"expert_a\"])\n return\n def _update_model(self):\n self.train()\n num_samples = self._exp_buffer.get_sample_count()\n batch_size = self._batch_size \n num_batches = int(np.ceil(float(num_samples) / batch_size))\n train_info = dict()\n for i in range(self._update_epochs):\n for b in range(num_batches):", "score": 0.9025955200195312 }, { "filename": "a1/bc_agent.py", "retrieved_chunk": " batch = self._exp_buffer.sample(batch_size)\n loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n num_steps = self._update_epochs * num_batches\n torch_util.scale_torch_dict(1.0 / num_steps, train_info)\n return train_info ", "score": 0.8553149104118347 }, { "filename": "learning/base_agent.py", "retrieved_chunk": " self._init_train()\n test_info = None\n while self._sample_count < max_samples:\n train_info = self._train_iter()\n output_iter = (self._iter % self._iters_per_output == 0)\n if (output_iter):\n test_info = self.test_model(self._test_episodes)\n self._sample_count = self._update_sample_count()\n self._log_train_info(train_info, test_info, start_time) \n self._logger.print_log()", "score": 0.8434406518936157 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " def _collect_init_samples(self, samples):\n self.eval()\n self.set_mode(base_agent.AgentMode.TRAIN)\n self._rollout_train(samples)\n return\n def _update_model(self):\n self.train()\n train_info = dict()\n for i in range(self._updates_per_iter):\n batch = self._exp_buffer.sample(self._batch_size)", "score": 0.8332358598709106 }, { "filename": "a3/dqn_agent.py", "retrieved_chunk": " loss_info = self._compute_loss(batch)\n self._optimizer.zero_grad()\n loss = loss_info[\"loss\"]\n loss.backward()\n self._optimizer.step()\n torch_util.add_torch_dict(loss_info, train_info)\n torch_util.scale_torch_dict(1.0 / self._updates_per_iter, train_info)\n if (self._iter % self._tar_net_update_iters == 0):\n self._sync_tar_model()\n return train_info", "score": 0.8319947719573975 } ]

[ { "filename": "src/Event/train_eval.py", "retrieved_chunk": " loss = trigger_loss + 2 * argument_loss\n else:\n loss = trigger_loss\n nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n loss.backward()\n optimizer.step()\n #\n # if i % 10 == 0: # monitoring\n # print(\"step: {}, loss: {}\".format(i, loss.item()))\ndef evaluate(model, iterator, f_name, f1_max=0):", "score": 0.8484419584274292 }, { "filename": "src/Entity/run_entity.py", "retrieved_chunk": " t_total = len(train_batches) * hparams.num_epoch\n scheduler = get_linear_schedule_with_warmup(optimizer, int(t_total * hparams.warmup_proportion), t_total)\n tr_loss = 0\n tr_examples = 0\n global_step = 0\n eval_step = len(train_batches) // hparams.eval_per_epoch\n for epoch in tqdm(range(hparams.num_epoch)):\n if hparams.train_shuffle:\n random.shuffle(train_batches)\n for i in tqdm(range(len(train_batches))):", "score": 0.8337826728820801 }, { "filename": "src/Entity/run_entity.py", "retrieved_chunk": " output_dict = model.run_batch(train_batches[i], training=True)\n loss = output_dict['ner_loss']\n loss.backward()\n tr_loss += loss.item()\n tr_examples += len(train_batches[i])\n global_step += 1\n optimizer.step()\n scheduler.step()\n optimizer.zero_grad()\n if global_step % hparams.print_loss_step == 0:", "score": 0.8320574760437012 }, { "filename": "src/Event/train.py", "retrieved_chunk": " batch_size=hp.batch_size,\n shuffle=False,\n num_workers=4,\n collate_fn=pad)\n optimizer = optim.Adam(model.parameters(), lr=hp.lr)\n # optimizer = optim.Adadelta(model.parameters(), lr=1.0, weight_decay=1e-2)\n criterion = nn.CrossEntropyLoss(ignore_index=0)\n if not os.path.exists(hp.logdir):\n os.makedirs(hp.logdir)\n f1_max_dev = 0", "score": 0.8307890892028809 }, { "filename": "src/Entity/run_entity.py", "retrieved_chunk": " logger.info('Epoch=%d, iter=%d, loss=%.5f' % (epoch, i, tr_loss / tr_examples))\n tr_loss = 0\n tr_examples = 0\n if global_step % eval_step == 0:\n f1 = evaluate(model, dev_batches, dev_ner)\n if f1 > best_result:\n best_result = f1\n logger.info('!!! Best valid (epoch=%d): %.2f' % (epoch, f1 * 100))\n save_model(model, hparams)\n if hparams.do_eval:", "score": 0.8209091424942017 } ]

[ { "filename": "tests/test_integration/test_v2/test_repository_long_running.py", "retrieved_chunk": " partition_ids, content_prefix=None, sort_ascending=True\n )\n for content in response.contents\n ]\n contents.sort()\n assert ascending_actual == contents\n descending_actual = [\n content\n for response in sync_v2_example_repo.list(\n partition_ids, content_prefix=None, sort_ascending=False", "score": 0.8568601608276367 }, { "filename": "tests/test_unit/test_v2/test_repository.py", "retrieved_chunk": " filters = FilterCommand(not_exists={\"optional_field\"})\n actual = [\n content\n async for response in repo.list_between(\n partition_id, content_start, content_end, ascending, limit, filters\n )\n for content in response.contents\n ]\n assert sorted(actual) == sorted(contents)\n args, kwargs = table.query.call_args", "score": 0.8563475012779236 }, { "filename": "tests/test_unit/test_repository.py", "retrieved_chunk": " ascending = random.choice((True, False))\n limit = fake.pyint()\n filters = FilterCommand(not_exists={\"failures\"})\n actual = list(\n repo.list_between(partition_id, content_start, content_end, ascending, limit, filters)\n )\n assert actual == [FieldModel(**item_dict)]\n args, kwargs = table.query.call_args\n assert kwargs[\"ScanIndexForward\"] == ascending\n assert \"Limit\" not in kwargs", "score": 0.8559561371803284 }, { "filename": "tests/test_unit/test_v2/test_repository.py", "retrieved_chunk": " ascending = random.choice((True, False))\n limit = 5\n actual = [\n content\n async for response in repo.list(partition_id, content_id, ascending, limit)\n for content in response.contents\n ]\n assert sorted(actual) == sorted(contents)\n assert len(table.query.call_args_list) == 2\n _, kwargs2 = table.query.call_args_list[1]", "score": 0.8453879356384277 }, { "filename": "tests/test_unit/test_v2/test_repository.py", "retrieved_chunk": " ascending = random.choice((True, False))\n limit = 5\n actual = [\n content\n async for response in repo.list(partition_id, content_id, ascending, limit)\n for content in response.contents\n ]\n assert sorted(actual) == sorted(contents[:6])\n assert len(table.query.call_args_list) == 2\n _, kwargs2 = table.query.call_args_list[1]", "score": 0.8434569835662842 } ]

[ { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " for seg_start_t, seg_end_t in zip(df['start'], df['end']):\n seg_start = int(seg_start_t * wav_sr)\n seg_end = int(seg_end_t * wav_sr)\n seg_waveform = waveform[:,seg_start:seg_end]\n n_test_frames = seg_waveform.shape[1]\n chunk_size = nmr_waveform.shape[1]\n step_size = (chunk_size * 0.5)\n current_id = 0\n mos_scores = []\n n_chunk = max(1, int(math.ceil((n_test_frames-chunk_size+step_size)/step_size)))", "score": 0.8875404596328735 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " result_dict[key] = []\n keys.append(key)\n for start_t, end_t in zip(df['start'], df['end']):\n seg_start = int(start_t * wav_sr)\n seg_end = int(end_t * wav_sr)\n scores_dict = {}\n for key in keys:\n scores_dict[key] = []\n seg_waveform = waveform[:,seg_start:seg_end]\n window_time = 3.0", "score": 0.8732234239578247 }, { "filename": "src/vad.py", "retrieved_chunk": " def apply_vad_segments(self, binary_segments, input_file_path, out_file_path):\n audio_arr, _ = librosa.load(input_file_path, sr=None)\n audio_seg_list = []\n for seg in binary_segments.get_timeline():\n start_f = int(seg.start * self.sr)\n end_f = int(seg.end * self.sr)\n audio_seg_list.append(audio_arr[start_f:end_f])\n vad_audio_arr = np.concatenate(audio_seg_list)\n sf.write(out_file_path, vad_audio_arr, self.sr)\n @staticmethod", "score": 0.8507827520370483 }, { "filename": "src/sqa.py", "retrieved_chunk": " mos_scores.append(mos_score)\n final_mos_score = np.mean(mos_scores)\n return final_mos_score\n def __call__(self, input_audio_path, seg_arr=None, verbose=False):\n waveform = load_audio(input_audio_path, sr=self.sr)\n waveform = torch.FloatTensor(waveform)\n if seg_arr is not None:\n mos_score_list = []\n for start, end in zip(seg_arr[:,0], seg_arr[:,1]):\n seg_waveform = waveform[start:end]", "score": 0.8439179062843323 }, { "filename": "main.py", "retrieved_chunk": " df = pd.read_csv(csv_path)\n else:\n df = detector(wav_path, results=asr_result, use_se=use_se,\n sc_chunk_time=args['sc_chunk_time'], sc_step_ratio=args['sc_step_ratio'])\n df_list[dir_name] = df\n del detector\n print(\"DONE SQA.\")\n for (wav_path, dir_name, asr_result) in tqdm.tqdm(zip(wav_list, dir_list, asr_result_list)):\n df = df_list[dir_name]\n result = write_results_json(wav_path, asr_result, df, args)", "score": 0.8345550298690796 } ]

[ { "filename": "src/custom_pyannote/speaker_verification.py", "retrieved_chunk": " continue\n if self_state[name].size() != loaded_state[origname].size():\n print(\"Wrong parameter length: {}, model: {}, loaded: {}\".format(origname, self_state[name].size(), loaded_state[origname].size()))\n continue\n self_state[name].copy_(param)\n def to(self, device: torch.device):\n self.classifier_ = MFA_Conformer()\n model_checkpoint_path = '/mnt/labelmaker/labelmaker/models/embedding/nnet/model.pth'\n self.loadParameters(model_checkpoint_path, device)\n self.classifier_.to(device)", "score": 0.8449405431747437 }, { "filename": "src/classify.py", "retrieved_chunk": " self.code2name = code2name\n # load BEATs\n model_ckpt_path: str = args['beats_model_ckpt_path']\n assert(os.path.exists(model_ckpt_path)), print('No Exists BEATs model file: {}'.format(model_ckpt_path))\n checkpoint = torch.load(model_ckpt_path)\n cfg = BEATsConfig(checkpoint['cfg'])\n self.model = BEATs(cfg)\n self.model.load_state_dict(checkpoint['model'])\n self.model.to(self.device)\n self.model.eval()", "score": 0.8180204629898071 }, { "filename": "src/beats/quantizer.py", "retrieved_chunk": " weight = torch.zeros(num_tokens, codebook_dim)\n self.register_buffer('initted', torch.Tensor([not kmeans_init]))\n else:\n print(f\"load init codebook weight from {codebook_init_path}\")\n codebook_ckpt_weight = torch.load(codebook_init_path, map_location='cpu')\n weight = codebook_ckpt_weight.clone()\n self.register_buffer('initted', torch.Tensor([True]))\n self.weight = nn.Parameter(weight, requires_grad=False)\n self.cluster_size = nn.Parameter(torch.zeros(num_tokens), requires_grad=False)\n self.embed_avg = nn.Parameter(weight.clone(), requires_grad=False)", "score": 0.8084198236465454 }, { "filename": "src/custom_pyannote/speaker_verification.py", "retrieved_chunk": " super().__init__()\n self.embedding = embedding\n self.device = device or torch.device(\"cpu\")\n self.use_auth_token = use_auth_token\n self.classifier_ = MFA_Conformer()\n model_checkpoint_path = '/mnt/labelmaker/labelmaker/models/embedding/nnet/model.pth'\n self.loadParameters(model_checkpoint_path, device)\n self.classifier_.eval()\n def loadParameters(self, path, device):\n self_state = self.classifier_.state_dict()", "score": 0.807008683681488 }, { "filename": "src/noresqa/model.py", "retrieved_chunk": " x = self.ebatch[i](x)\n if i!=2:\n x = F.leaky_relu(x,0.1)\n x = self.dp[i](x)\n return x\nclass NORESQA(nn.Module):\n def __init__(self, dev=torch.device('cpu'), minit=1, output=20, output2=16, config_path='models/wav2vec_small.pt'):\n super(NORESQA, self).__init__()\n SSL_OUT_DIM=768\n ssl_model, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task([config_path])", "score": 0.7599164843559265 } ]

[ { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " for seg_start_t, seg_end_t in zip(df['start'], df['end']):\n seg_start = int(seg_start_t * wav_sr)\n seg_end = int(seg_end_t * wav_sr)\n seg_waveform = waveform[:,seg_start:seg_end]\n n_test_frames = seg_waveform.shape[1]\n chunk_size = nmr_waveform.shape[1]\n step_size = (chunk_size * 0.5)\n current_id = 0\n mos_scores = []\n n_chunk = max(1, int(math.ceil((n_test_frames-chunk_size+step_size)/step_size)))", "score": 0.8741710186004639 }, { "filename": "src/classify.py", "retrieved_chunk": " n_test_frames = waveform.shape[1]\n pred_list = []\n n_chunk = max(1, int(math.ceil((n_test_frames-chunk_size+step_size)/step_size)))\n for chunk_id in range(n_chunk):\n start = int(step_size * chunk_id)\n end = min(start + chunk_size, n_test_frames)\n duration = int(end-start)\n chunk_waveform = torch.zeros(1,chunk_size).to(self.device)\n chunk_waveform[:,:duration] = waveform[:,start:end]\n chunk_mask = None", "score": 0.853056788444519 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " n_chunk = int((n_samples-1)/batch_size) + 1\n scores = []\n with torch.no_grad():\n for chunk_id in range(n_chunk):\n b_start = chunk_id * batch_size\n b_end = min((chunk_id+1) * batch_size, n_samples)\n score = model(chunk_test_waveform[b_start:b_end], chunk_nmr_waveform[b_start:b_end])\n scores.append(score)\n scores = torch.concat(scores)\n score = scores.mean().detach().cpu().item()", "score": 0.8291056752204895 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " for chunk_id in range(n_chunk):\n start = int(step_size * chunk_id)\n end = min(start + chunk_size, n_test_frames)\n duration = int(end-start)\n chunk_test_waveform = seg_waveform[:, start:end]\n chunk_test_waveform = chunk_test_waveform.repeat(nmr_wav_arr.shape[0], 1)\n chunk_test_waveform = chunk_test_waveform.to(device)\n chunk_nmr_waveform = nmr_waveform[:,:duration]\n batch_size = 32\n n_samples = chunk_test_waveform.shape[0]", "score": 0.8246232271194458 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " window_size = int(wav_sr * window_time)\n stride_size = int(0.5 * window_size)\n n_frames = int(seg_waveform.shape[1])\n n_chunks = max(1, math.ceil((n_frames-window_size+stride_size)/stride_size))\n for chunk_id in range(n_chunks):\n start = int(stride_size * chunk_id)\n end = min(start + window_size, n_frames)\n chunk_waveform = seg_waveform[:, start:end]\n with torch.no_grad():\n scores = model(chunk_waveform)", "score": 0.8211617469787598 } ]

[ { "filename": "api/src/llm/openai.py", "retrieved_chunk": " def __init__(\n self,\n openai_api_key: str,\n model_name: str = \"gpt-3.5-turbo\",\n max_tokens: int = 1000,\n temperature: float = 0.0,\n ) -> None:\n openai.api_key = openai_api_key\n self.model = model_name\n self.max_tokens = max_tokens", "score": 0.8677451014518738 }, { "filename": "api/src/main.py", "retrieved_chunk": " \"\"\"\n Takes an input and created a Cypher query\n \"\"\"\n if not openai_api_key and not payload.api_key:\n raise HTTPException(\n status_code=422,\n detail=\"Please set OPENAI_API_KEY environment variable or send it as api_key in the request body\",\n )\n api_key = openai_api_key if openai_api_key else payload.api_key\n try:", "score": 0.7685537338256836 }, { "filename": "api/src/main.py", "retrieved_chunk": " api_key: Optional[str]\n# This endpoint is database specific and only works with the Demo database.\n@app.post(\"/companyReport\")\nasync def companyInformation(payload: companyReportPayload):\n api_key = openai_api_key if openai_api_key else payload.api_key\n if not openai_api_key and not payload.api_key:\n raise HTTPException(\n status_code=422,\n detail=\"Please set OPENAI_API_KEY environment variable or send it as api_key in the request body\",\n )", "score": 0.7629135847091675 }, { "filename": "api/src/main.py", "retrieved_chunk": " questionProposalGenerator = QuestionProposalGenerator(\n database=neo4j_connection,\n llm=OpenAIChat(\n openai_api_key=api_key,\n model_name=\"gpt-3.5-turbo-0613\",\n max_tokens=512,\n temperature=0.8,\n ),\n )\n return questionProposalGenerator.run()", "score": 0.7598438262939453 }, { "filename": "api/src/main.py", "retrieved_chunk": " allow_headers=[\"*\"],\n)\n@app.post(\"/questionProposalsForCurrentDb\")\nasync def questionProposalsForCurrentDb(payload: questionProposalPayload):\n if not openai_api_key and not payload.api_key:\n raise HTTPException(\n status_code=422,\n detail=\"Please set OPENAI_API_KEY environment variable or send it as api_key in the request body\",\n )\n api_key = openai_api_key if openai_api_key else payload.api_key", "score": 0.7542689442634583 } ]

[ { "filename": "src/custom_pyannote/speaker_verification.py", "retrieved_chunk": " if max_len < self.min_num_samples:\n return np.NAN * np.zeros((batch_size, self.dimension))\n too_short = wav_lens < self.min_num_samples\n wav_lens[too_short] = max_len\n _, embeddings = self.model_(\n input_signal=waveforms.to(self.device),\n input_signal_length=wav_lens.to(self.device),\n )\n embeddings = embeddings.cpu().numpy()\n embeddings[too_short.cpu().numpy()] = np.NAN", "score": 0.8487916588783264 }, { "filename": "src/beats/backbone.py", "retrieved_chunk": " if src_len > prev_key_padding_mask.size(1):\n filler = torch.zeros(\n (batch_size, src_len - prev_key_padding_mask.size(1)),\n device=prev_key_padding_mask.device,\n )\n new_key_padding_mask = torch.cat(\n [prev_key_padding_mask.float(), filler.float()], dim=1\n )\n else:\n new_key_padding_mask = prev_key_padding_mask.float()", "score": 0.8400932550430298 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " n_chunk = int((n_samples-1)/batch_size) + 1\n scores = []\n with torch.no_grad():\n for chunk_id in range(n_chunk):\n b_start = chunk_id * batch_size\n b_end = min((chunk_id+1) * batch_size, n_samples)\n score = model(chunk_test_waveform[b_start:b_end], chunk_nmr_waveform[b_start:b_end])\n scores.append(score)\n scores = torch.concat(scores)\n score = scores.mean().detach().cpu().item()", "score": 0.8312303423881531 }, { "filename": "src/custom_pyannote/speaker_diarization.py", "retrieved_chunk": " masks = np.nan_to_num(masks, nan=0.0).astype(np.float32)\n clean_masks = np.nan_to_num(clean_masks, nan=0.0).astype(np.float32)\n for mask, clean_mask in zip(masks.T, clean_masks.T):\n # mask: (num_frames, ) np.ndarray\n if np.sum(clean_mask) > min_num_frames:\n used_mask = clean_mask\n else:\n used_mask = mask\n yield waveform[None], torch.from_numpy(used_mask)[None]\n # w: (1, 1, num_samples) torch.Tensor", "score": 0.8283250331878662 }, { "filename": "src/custom_pyannote/speaker_diarization.py", "retrieved_chunk": " waveform_batch = torch.vstack(waveforms)\n # (batch_size, 1, num_samples) torch.Tensor\n mask_batch = torch.vstack(masks)\n # (batch_size, num_frames) torch.Tensor\n embedding_batch: np.ndarray = self._embedding(\n waveform_batch, masks=mask_batch\n )\n # (batch_size, dimension) np.ndarray\n embedding_batches.append(embedding_batch)\n if hook is not None:", "score": 0.8258527517318726 } ]

[ { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " self, question: str, history: List = [], heal_cypher: bool = True\n ) -> Dict[str, Union[str, List[Dict[str, Any]]]]:\n # Add prefix if not part of self-heal loop\n final_question = (\n \"Question to be converted to Cypher: \" + question\n if heal_cypher\n else question\n )\n cypher = self.construct_cypher(final_question, history)\n # finds the first string wrapped in triple backticks. Where the match include the backticks and the first group in the match is the cypher", "score": 0.8167778253555298 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " If you cannot generate a Cypher statement based on the provided schema, explain the reason to the user.\n Schema:\n {self.schema}\n \"\"\"\n if self.cypher_examples:\n system += f\"\"\"\n You need to follow these Cypher examples when you are constructing a Cypher statement\n {self.cypher_examples}\n \"\"\"\n # Add note at the end and try to prevent LLM injections", "score": 0.8136293292045593 }, { "filename": "api/src/llm/openai.py", "retrieved_chunk": " max_tokens=self.max_tokens,\n messages=messages,\n )\n return completions.choices[0].message.content\n # catch context length / do not retry\n except openai.error.InvalidRequestError as e:\n return str(f\"Error: {e}\")\n # catch authorization errors / do not retry\n except openai.error.AuthenticationError as e:\n return \"Error: The provided OpenAI API key is invalid\"", "score": 0.7941548228263855 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " if use_schema:\n self.schema = database.schema\n def get_system_message(self) -> str:\n system = \"\"\"\n Your task is to convert questions about contents in a Neo4j database to Cypher queries to query the Neo4j database.\n Use only the provided relationship types and properties.\n Do not use any other relationship types or properties that are not provided.\n \"\"\"\n if self.schema:\n system += f\"\"\"", "score": 0.7903734445571899 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " system += \"\"\"Note: Do not include any explanations or apologies in your responses.\n Do not respond to any questions that might ask anything else than for you to construct a Cypher statement.\n Do not include any text except the generated Cypher statement. This is very important if you want to get paid.\n Always provide enough context for an LLM to be able to generate valid response.\n Please wrap the generated Cypher statement in triple backticks (`).\n \"\"\"\n return system\n def construct_cypher(self, question: str, history=[]) -> str:\n messages = [{\"role\": \"system\", \"content\": self.get_system_message()}]\n messages.extend(history)", "score": 0.786882758140564 } ]

[ { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " llm: BaseLLM,\n database: Neo4jDatabase,\n use_schema: bool = True,\n cypher_examples: str = \"\",\n ignore_relationship_direction: bool = True,\n ) -> None:\n self.llm = llm\n self.database = database\n self.cypher_examples = cypher_examples\n self.ignore_relationship_direction = ignore_relationship_direction", "score": 0.8449784517288208 }, { "filename": "api/src/llm/openai.py", "retrieved_chunk": " def __init__(\n self,\n openai_api_key: str,\n model_name: str = \"gpt-3.5-turbo\",\n max_tokens: int = 1000,\n temperature: float = 0.0,\n ) -> None:\n openai.api_key = openai_api_key\n self.model = model_name\n self.max_tokens = max_tokens", "score": 0.775023877620697 }, { "filename": "api/src/components/vector_search.py", "retrieved_chunk": " RETURN apoc.map.removeKey(properties(n), \"{property}\") AS output\n \"\"\"\nclass VectorSearch(BaseComponent):\n def __init__(\n self, database: Neo4jDatabase, label: str, property: str, k: int\n ) -> None:\n self.database = database\n self.generated_cypher = construct_cypher(label, property, k)\n def run(self, input: str) -> Dict[str, Union[str, List[Dict[str, str]]]]:\n try:", "score": 0.7511516809463501 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " if use_schema:\n self.schema = database.schema\n def get_system_message(self) -> str:\n system = \"\"\"\n Your task is to convert questions about contents in a Neo4j database to Cypher queries to query the Neo4j database.\n Use only the provided relationship types and properties.\n Do not use any other relationship types or properties that are not provided.\n \"\"\"\n if self.schema:\n system += f\"\"\"", "score": 0.7500661015510559 }, { "filename": "api/src/components/question_proposal_generator.py", "retrieved_chunk": "from typing import Any, Dict, List, Union\nfrom components.base_component import BaseComponent\nfrom driver.neo4j import Neo4jDatabase\nfrom llm.basellm import BaseLLM\nimport re\nclass QuestionProposalGenerator(BaseComponent):\n def __init__(\n self,\n llm: BaseLLM,\n database: Neo4jDatabase,", "score": 0.7322869896888733 } ]

[ { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " if not wav_path.startswith('.')]\n assert(len(nmr_wav_list) == DAPS_N_CLEAN_WAV_NUM), \"Error not match NMR wav file number: {} : 100\".foramt(len(nmr_wav_list))\n nmr_wav_arr = []\n for nmr_wav_path in nmr_wav_list:\n nmr_waveform = load_audio(nmr_wav_path, sr=wav_sr, chunk_time=max_nmr_wav_time)\n # nmr_waveform shape: (wav_sr*max_nmr_wav_time,)\n nmr_wav_arr.append(nmr_waveform)\n nmr_wav_arr = np.stack(nmr_wav_arr)\n np.save(nmr_wav_npy, nmr_wav_arr)\n else:", "score": 0.8416756391525269 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " use_round = True\n max_nmr_wav_time = 3.0\n device = torch.device(\"cuda\")\n set_seeds()\n nmr_dir = '/mnt/dataset/daps'\n nmr_wav_npy = os.path.join(nmr_dir, 'clean_nmr_n100_{}ms.npy'.format(max_nmr_wav_time*1000))\n if not os.path.exists(nmr_wav_npy):\n print(\">>Prepare nmr waveforms\")\n nmr_wav_list = sorted(glob.glob(nmr_dir+\"/daps/clean/*.wav\"))\n nmr_wav_list = [wav_path for wav_path in nmr_wav_list", "score": 0.8199893236160278 }, { "filename": "src/torchaudio_squim/run_squim.py", "retrieved_chunk": " model.eval()\n csv_list = sorted(glob.glob(result_csv_dir+\"/*.csv\"))\n for csv_path in tqdm.tqdm(csv_list):\n yt_name = os.path.splitext(os.path.basename(csv_path))[0]\n wav_path = os.path.join(root_wav_dir, yt_name, 'wav', yt_name+'.wav')\n assert(os.path.exists(wav_path)), \"No Exists Wav File: {}\".format(wav_path)\n df = pd.read_csv(csv_path)\n waveform, sr = torchaudio.load(wav_path)\n nmr_waveform = torch.FloatTensor(nmr_wav_arr).to(device)\n mos_score_list = []", "score": 0.8161499500274658 }, { "filename": "src/noresqa/model.py", "retrieved_chunk": " quantf = self.quantification(merged_emb, n_wins_tensor)\n att = F.softmax(quantf, dim=1)\n B = torch.linspace(0, 4, steps=5).to(merged_emb.device)\n mos_score = (att*B).sum(axis=1)\n return 5.0 - mos_score\n def estimate_score_bw_embs(self, emb1, emb2, mask=None):\n merged_emb = torch.cat((emb1, emb2), 1)\n # n_wins = merged_emb.shape[2]\n # B = [n_wins for n in range(merged_emb.shape[0])]\n # n_wins_tensor = torch.from_numpy(np.asarray(B)).to(merged_emb.device)", "score": 0.8109676241874695 }, { "filename": "src/custom_pyannote/speaker_verification.py", "retrieved_chunk": " if max_len < self.min_num_samples:\n return np.NAN * np.zeros((batch_size, self.dimension))\n too_short = wav_lens < self.min_num_samples\n wav_lens[too_short] = max_len\n _, embeddings = self.model_(\n input_signal=waveforms.to(self.device),\n input_signal_length=wav_lens.to(self.device),\n )\n embeddings = embeddings.cpu().numpy()\n embeddings[too_short.cpu().numpy()] = np.NAN", "score": 0.7963631749153137 } ]

[ { "filename": "api/src/llm/openai.py", "retrieved_chunk": " max_tokens=self.max_tokens,\n messages=messages,\n )\n return completions.choices[0].message.content\n # catch context length / do not retry\n except openai.error.InvalidRequestError as e:\n return str(f\"Error: {e}\")\n # catch authorization errors / do not retry\n except openai.error.AuthenticationError as e:\n return \"Error: The provided OpenAI API key is invalid\"", "score": 0.8311426639556885 }, { "filename": "api/src/main.py", "retrieved_chunk": " await sendErrorMessage(str(e))\n continue\n if results == None:\n await sendErrorMessage(\"Could not generate Cypher statement\")\n continue\n await websocket.send_json(\n {\n \"type\": \"start\",\n }\n )", "score": 0.8100342750549316 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " If you cannot generate a Cypher statement based on the provided schema, explain the reason to the user.\n Schema:\n {self.schema}\n \"\"\"\n if self.cypher_examples:\n system += f\"\"\"\n You need to follow these Cypher examples when you are constructing a Cypher statement\n {self.cypher_examples}\n \"\"\"\n # Add note at the end and try to prevent LLM injections", "score": 0.7974696755409241 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " system += \"\"\"Note: Do not include any explanations or apologies in your responses.\n Do not respond to any questions that might ask anything else than for you to construct a Cypher statement.\n Do not include any text except the generated Cypher statement. This is very important if you want to get paid.\n Always provide enough context for an LLM to be able to generate valid response.\n Please wrap the generated Cypher statement in triple backticks (`).\n \"\"\"\n return system\n def construct_cypher(self, question: str, history=[]) -> str:\n messages = [{\"role\": \"system\", \"content\": self.get_system_message()}]\n messages.extend(history)", "score": 0.7948070764541626 }, { "filename": "api/src/components/text2cypher.py", "retrieved_chunk": " self, question: str, history: List = [], heal_cypher: bool = True\n ) -> Dict[str, Union[str, List[Dict[str, Any]]]]:\n # Add prefix if not part of self-heal loop\n final_question = (\n \"Question to be converted to Cypher: \" + question\n if heal_cypher\n else question\n )\n cypher = self.construct_cypher(final_question, history)\n # finds the first string wrapped in triple backticks. Where the match include the backticks and the first group in the match is the cypher", "score": 0.7765446901321411 } ]

[ { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " conversation_id (str): ID of the conversation to add the message to.\n human (str): User message.\n assistant (str): Assistant message.\n \"\"\"\n document: Dict = {\"text\": f\"Human: {human}\\nAssistant: {assistant}\", \"conversation_id\": conversation_id}\n document[\"embedding\"] = self.embed_client.embed_documents(docs=[document])[0].astype(np.float32).tobytes()\n self.datastore.index_documents(documents=[document])\n # optionally check if it is a new conversation\n self.add_conversation(Memory(conversation_id=conversation_id))\n def get_messages(self, query: str, topk: int = 5, **kwargs) -> List[Any]:", "score": 0.7864947319030762 }, { "filename": "tests/test_memory_manager.py", "retrieved_chunk": " # assert that the memory manager is empty\n assert len(memory_manager.conversations) == 0\n def test_adding_messages_to_conversation(self):\n # create a memory manager\n memory_manager = MemoryManager(datastore=self.datastore, embed_client=self.embedding_client)\n # add a conversation to the memory manager\n memory_manager.add_conversation(Memory(conversation_id=\"1\"))\n # assert that the memory manager has 1 conversation\n assert len(memory_manager.conversations) == 1\n # add a message to the conversation", "score": 0.7653625011444092 }, { "filename": "tests/test_memory_manager.py", "retrieved_chunk": " memory_manager.add_message(conversation_id=\"1\", human=\"Hello\", assistant=\"Hello. How are you?\")\n # get messages for that conversation\n messages = memory_manager.get_messages(conversation_id=\"1\", query=\"Hello\")\n # assert that the message was added\n assert len(messages) == 1\n # assert that the message is correct\n assert messages[0].text == \"Human: Hello\\nAssistant: Hello. How are you?\"\n assert messages[0].conversation_id == \"1\"", "score": 0.7583318948745728 }, { "filename": "rest_api.py", "retrieved_chunk": "# port=REDIS_PORT,\n# password=REDIS_PASSWORD,\n# )\n# # Instantiate a RedisDataStore object with the RedisDataStoreConfig object\n# redis_datastore = RedisDataStore(config=redis_datastore_config, do_flush_data=True)\n# # Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object\n# memory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)\n# # Instantiate a ChatGPTConfig object with the OpenAI API key and verbose set to True\n# chat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=False)\n# # Instantiate a ChatGPTClient object with the ChatGPTConfig object and MemoryManager object", "score": 0.7522240877151489 }, { "filename": "acad_gpt/llm_client/openai/conversation/chatgpt_client.py", "retrieved_chunk": " chat_gpt_answer: str\nclass ChatGPTClient(LLMClient):\n \"\"\"\n ChatGPT client allows to interact with the ChatGPT model alonside having infinite contextual and adaptive memory.\n \"\"\"\n def __init__(self, config: ChatGPTConfig, memory_manager: MemoryManager):\n super().__init__(config=config)\n prompt = PromptTemplate(input_variables=[\"prompt\"], template=\"{prompt}\")\n self.chatgpt_chain = LLMChain(\n llm=OpenAI(", "score": 0.7446470260620117 } ]

[ { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " conversation_id (str): ID of the conversation to add the message to.\n human (str): User message.\n assistant (str): Assistant message.\n \"\"\"\n document: Dict = {\"text\": f\"Human: {human}\\nAssistant: {assistant}\", \"conversation_id\": conversation_id}\n document[\"embedding\"] = self.embed_client.embed_documents(docs=[document])[0].astype(np.float32).tobytes()\n self.datastore.index_documents(documents=[document])\n # optionally check if it is a new conversation\n self.add_conversation(Memory(conversation_id=conversation_id))\n def get_messages(self, query: str, topk: int = 5, **kwargs) -> List[Any]:", "score": 0.8417304754257202 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " \"\"\"\n self.datastore = datastore\n self.embed_client = embed_client\n self.topk = topk\n self.conversations: List[Memory] = [\n Memory(conversation_id=conversation_id) for conversation_id in datastore.get_all_document_ids()\n ]\n def __del__(self) -> None:\n \"\"\"Clear the memory manager when manager is deleted.\"\"\"\n self.clear()", "score": 0.8190096616744995 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " Removes a conversation from the memory manager.\n Args:\n conversation (Memory): Conversation to be removed containing `conversation_id`.\n \"\"\"\n if conversation not in self.conversations:\n return\n conversation_idx = self.conversations.index(conversation)\n if conversation_idx >= 0:\n del self.conversations[conversation_idx]\n self.datastore.delete_documents(document_id=conversation.conversation_id)", "score": 0.8050470352172852 }, { "filename": "examples/simple_usage.py", "retrieved_chunk": "conversation_id = None\n# Start the chatbot loop\nwhile True:\n # Prompt the user for input\n user_message = input(\"\\n Please enter your message: \")\n # Use the ChatGPTClient object to generate a response\n response = chat_gpt_client.converse(message=user_message, conversation_id=conversation_id)\n # Update the conversation_id with the conversation_id from the response\n conversation_id = response.conversation_id\n # Print the response generated by the chatbot", "score": 0.75079345703125 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " def add_conversation(self, conversation: Memory) -> None:\n \"\"\"\n Adds a conversation to the memory manager to be stored and manage.\n Args:\n conversation (Memory): Conversation to be added.\n \"\"\"\n if conversation not in self.conversations:\n self.conversations.append(conversation)\n def remove_conversation(self, conversation: Memory) -> None:\n \"\"\"", "score": 0.7146257162094116 } ]

[ { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " \"\"\"\n self.datastore = datastore\n self.embed_client = embed_client\n self.topk = topk\n self.conversations: List[Memory] = [\n Memory(conversation_id=conversation_id) for conversation_id in datastore.get_all_document_ids()\n ]\n def __del__(self) -> None:\n \"\"\"Clear the memory manager when manager is deleted.\"\"\"\n self.clear()", "score": 0.8354606628417969 }, { "filename": "tests/test_redis_datastore.py", "retrieved_chunk": "]\ndef test_redis_datastore(redis_datastore: RedisDataStore):\n embedding_config = EmbeddingConfig(api_key=OPENAI_API_KEY)\n openai_embedding_client = EmbeddingClient(config=embedding_config)\n assert (\n redis_datastore.redis_connection.ping()\n ), \"Redis connection failed,\\\n double check your connection parameters\"\n document_embeddings: np.ndarray = openai_embedding_client.embed_documents(SAMPLE_DOCUMENTS)\n for idx, embedding in enumerate(document_embeddings):", "score": 0.806194543838501 }, { "filename": "examples/simple_usage.py", "retrieved_chunk": ")\n# Instantiate a RedisDataStore object with the RedisDataStoreConfig object\nredis_datastore = RedisDataStore(config=redis_datastore_config)\n# Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object\nmemory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)\n# Instantiate a ChatGPTConfig object with the OpenAI API key and verbose set to True\nchat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=False)\n# Instantiate a ChatGPTClient object with the ChatGPTConfig object and MemoryManager object\nchat_gpt_client = ChatGPTClient(config=chat_gpt_config, memory_manager=memory_manager)\n# Initialize conversation_id to None", "score": 0.7897502183914185 }, { "filename": "acad_bot.py", "retrieved_chunk": " password=ES_PASSWORD,\n index_name=ES_INDEX,\n)\nes_datastore = ElasticSearchDataStore(config=es_datastore_config)\n# Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object\nmemory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)\nchat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=False)\nchat_gpt_client = ChatGPTClient(config=chat_gpt_config, memory_manager=memory_manager)\nintents = discord.Intents.default()\nintents.message_content = True", "score": 0.7821568846702576 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " conversation_id (str): ID of the conversation to add the message to.\n human (str): User message.\n assistant (str): Assistant message.\n \"\"\"\n document: Dict = {\"text\": f\"Human: {human}\\nAssistant: {assistant}\", \"conversation_id\": conversation_id}\n document[\"embedding\"] = self.embed_client.embed_documents(docs=[document])[0].astype(np.float32).tobytes()\n self.datastore.index_documents(documents=[document])\n # optionally check if it is a new conversation\n self.add_conversation(Memory(conversation_id=conversation_id))\n def get_messages(self, query: str, topk: int = 5, **kwargs) -> List[Any]:", "score": 0.7720240354537964 } ]

[ { "filename": "tests/test_redis_datastore.py", "retrieved_chunk": "]\ndef test_redis_datastore(redis_datastore: RedisDataStore):\n embedding_config = EmbeddingConfig(api_key=OPENAI_API_KEY)\n openai_embedding_client = EmbeddingClient(config=embedding_config)\n assert (\n redis_datastore.redis_connection.ping()\n ), \"Redis connection failed,\\\n double check your connection parameters\"\n document_embeddings: np.ndarray = openai_embedding_client.embed_documents(SAMPLE_DOCUMENTS)\n for idx, embedding in enumerate(document_embeddings):", "score": 0.8694585561752319 }, { "filename": "examples/simple_usage.py", "retrieved_chunk": ")\n# Instantiate a RedisDataStore object with the RedisDataStoreConfig object\nredis_datastore = RedisDataStore(config=redis_datastore_config)\n# Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object\nmemory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)\n# Instantiate a ChatGPTConfig object with the OpenAI API key and verbose set to True\nchat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=False)\n# Instantiate a ChatGPTClient object with the ChatGPTConfig object and MemoryManager object\nchat_gpt_client = ChatGPTClient(config=chat_gpt_config, memory_manager=memory_manager)\n# Initialize conversation_id to None", "score": 0.8393053412437439 }, { "filename": "acad_bot.py", "retrieved_chunk": " password=ES_PASSWORD,\n index_name=ES_INDEX,\n)\nes_datastore = ElasticSearchDataStore(config=es_datastore_config)\n# Instantiate a MemoryManager object with the RedisDataStore object and EmbeddingClient object\nmemory_manager = MemoryManager(datastore=redis_datastore, embed_client=embed_client, topk=1)\nchat_gpt_config = ChatGPTConfig(api_key=OPENAI_API_KEY, verbose=False)\nchat_gpt_client = ChatGPTClient(config=chat_gpt_config, memory_manager=memory_manager)\nintents = discord.Intents.default()\nintents.message_content = True", "score": 0.8287023305892944 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " \"\"\"\n self.datastore = datastore\n self.embed_client = embed_client\n self.topk = topk\n self.conversations: List[Memory] = [\n Memory(conversation_id=conversation_id) for conversation_id in datastore.get_all_document_ids()\n ]\n def __del__(self) -> None:\n \"\"\"Clear the memory manager when manager is deleted.\"\"\"\n self.clear()", "score": 0.8130961656570435 }, { "filename": "examples/simple_usage.py", "retrieved_chunk": "from acad_gpt.memory import MemoryManager\n# Instantiate an EmbeddingConfig object with the OpenAI API key\nembedding_config = EmbeddingConfig(api_key=OPENAI_API_KEY)\n# Instantiate an EmbeddingClient object with the EmbeddingConfig object\nembed_client = EmbeddingClient(config=embedding_config)\n# Instantiate a RedisDataStoreConfig object with the Redis connection details\nredis_datastore_config = RedisDataStoreConfig(\n host=REDIS_HOST,\n port=REDIS_PORT,\n password=REDIS_PASSWORD,", "score": 0.8045326471328735 } ]

[ { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " \"\"\"\n self.datastore = datastore\n self.embed_client = embed_client\n self.topk = topk\n self.conversations: List[Memory] = [\n Memory(conversation_id=conversation_id) for conversation_id in datastore.get_all_document_ids()\n ]\n def __del__(self) -> None:\n \"\"\"Clear the memory manager when manager is deleted.\"\"\"\n self.clear()", "score": 0.8230786323547363 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " conversation_id (str): ID of the conversation to add the message to.\n human (str): User message.\n assistant (str): Assistant message.\n \"\"\"\n document: Dict = {\"text\": f\"Human: {human}\\nAssistant: {assistant}\", \"conversation_id\": conversation_id}\n document[\"embedding\"] = self.embed_client.embed_documents(docs=[document])[0].astype(np.float32).tobytes()\n self.datastore.index_documents(documents=[document])\n # optionally check if it is a new conversation\n self.add_conversation(Memory(conversation_id=conversation_id))\n def get_messages(self, query: str, topk: int = 5, **kwargs) -> List[Any]:", "score": 0.8228662014007568 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " Removes a conversation from the memory manager.\n Args:\n conversation (Memory): Conversation to be removed containing `conversation_id`.\n \"\"\"\n if conversation not in self.conversations:\n return\n conversation_idx = self.conversations.index(conversation)\n if conversation_idx >= 0:\n del self.conversations[conversation_idx]\n self.datastore.delete_documents(document_id=conversation.conversation_id)", "score": 0.8061567544937134 }, { "filename": "acad_gpt/memory/manager.py", "retrieved_chunk": " def add_conversation(self, conversation: Memory) -> None:\n \"\"\"\n Adds a conversation to the memory manager to be stored and manage.\n Args:\n conversation (Memory): Conversation to be added.\n \"\"\"\n if conversation not in self.conversations:\n self.conversations.append(conversation)\n def remove_conversation(self, conversation: Memory) -> None:\n \"\"\"", "score": 0.7271147966384888 }, { "filename": "examples/simple_usage.py", "retrieved_chunk": "conversation_id = None\n# Start the chatbot loop\nwhile True:\n # Prompt the user for input\n user_message = input(\"\\n Please enter your message: \")\n # Use the ChatGPTClient object to generate a response\n response = chat_gpt_client.converse(message=user_message, conversation_id=conversation_id)\n # Update the conversation_id with the conversation_id from the response\n conversation_id = response.conversation_id\n # Print the response generated by the chatbot", "score": 0.7194198966026306 } ]

[ { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": " pstate.cpu.r0 = 1\n elif addr == STUB_ADDR2:\n pstate.cpu.r0 = 0\n pstate.cpu.program_counter += 2\n exec.skip_instruction()\ndef hook_start(exec: SymbolicExecutor, pstate: ProcessState):\n buffer = pstate.get_argument_value(0)\n length = pstate.get_argument_value(1)\n JSON_ctx = pstate.get_argument_value(2)\n exec.inject_symbolic_variable_memory(buffer, \"buffer\", exec.seed.content.variables[\"buffer\"])", "score": 0.8526053428649902 }, { "filename": "doc/practicals/solutions_toy_examples/solve6.py", "retrieved_chunk": " new_seed = se.mk_new_seed_from_model(model)\n #new_seed.status = SeedStatus.CRASH\n se.enqueue_seed(new_seed) \ndef trace_inst(exec: SymbolicExecutor, pstate: ProcessState, inst: Instruction):\n print(f\"[tid:{inst.getThreadId()}] 0x{inst.getAddress():x}: {inst.getDisassembly()}\")\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"seed:{se.seed.hash} ({repr(se.seed.content)}) [exitcode:{se.exitcode}]\")\ndef hook_alert_placeholder(exec: SymbolicExecutor, pstate: ProcessState, addr: int):\n buffer_len = pstate.get_argument_value(2)\n buffer_addr = pstate.get_argument_value(3)", "score": 0.8331025242805481 }, { "filename": "doc/practicals/solutions_toy_examples/solve6.py", "retrieved_chunk": " buffers_len_g[buffer_addr] = buffer_len\np = Program(\"./6\")\nalert_placeholder_addr = p.find_function_addr(\"__alert_placeholder\")\ndse = SymbolicExplorator(Config(symbolize_argv=True, skip_unsupported_import=True), p)\ndse.add_input_seed(Seed(b\"./6\\x00AZERAZER\\x00AZERAZER\"))\ndse.callback_manager.register_post_execution_callback(post_exec_hook)\n#dse.callback_manager.register_post_instruction_callback(trace_inst)\ndse.callback_manager.register_pre_addr_callback(alert_placeholder_addr, hook_alert_placeholder)\ndse.callback_manager.register_probe(StrncpySanitizer())\ndse.callback_manager.register_probe(NullDerefSanitizer())", "score": 0.8301239013671875 }, { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": " exec.inject_symbolic_variable_memory(JSON_ctx, \"JSON_ctx\", exec.seed.content.variables[\"JSON_ctx\"])\n # Take the length of the buffer (which is not meant to change)\n pstate.cpu.r1 = len(exec.seed.content.variables['buffer'])\nconf = Config(skip_unsupported_import=True, seed_format=SeedFormat.COMPOSITE, smt_solver=SmtSolver.Z3)\nraw_firmware = Path(\"./bugged_json_parser.bin\").read_bytes()\nldr = MonolithicLoader(Architecture.ARM32,\n cpustate = {\"pc\": ENTRY_POINT, \n \"r0\": BUFFER_ADDR,\n \"r2\": STRUC_ADDR,\n \"sp\": STACK_ADDR+STACK_SIZE},", "score": 0.7560760974884033 }, { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": "def pre_inst(se: SymbolicExecutor, state: ProcessState, inst):\n if se.trace_offset > 40000:\n se.seed.status = SeedStatus.HANG\n se.abort()\n #print(f\"[{se.trace_offset}] {inst.getAddress():#08x}: {inst.getDisassembly()}\")\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"[{se.uid}] seed:{se.seed.hash} ({repr(se.seed.content.variables['buffer'][:100])}) => {se.seed.status.name} [exitcode:{se.exitcode}]\")\ndef fptr_stub(exec: SymbolicExecutor, pstate: ProcessState, addr: int):\n print(f\"fptr_stub addr : {addr:#x}\")\n if addr == STUB_ADDR1:", "score": 0.7543609738349915 } ]

[ { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": " exec.inject_symbolic_variable_memory(JSON_ctx, \"JSON_ctx\", exec.seed.content.variables[\"JSON_ctx\"])\n # Take the length of the buffer (which is not meant to change)\n pstate.cpu.r1 = len(exec.seed.content.variables['buffer'])\nconf = Config(skip_unsupported_import=True, seed_format=SeedFormat.COMPOSITE, smt_solver=SmtSolver.Z3)\nraw_firmware = Path(\"./bugged_json_parser.bin\").read_bytes()\nldr = MonolithicLoader(Architecture.ARM32,\n cpustate = {\"pc\": ENTRY_POINT, \n \"r0\": BUFFER_ADDR,\n \"r2\": STRUC_ADDR,\n \"sp\": STACK_ADDR+STACK_SIZE},", "score": 0.7464356422424316 }, { "filename": "doc/practicals/solutions_toy_examples/solve4.py", "retrieved_chunk": " new_seed = se.mk_new_seed_from_model(model)\n print(f\"new_seed : {new_seed.content}\")\n se.enqueue_seed(new_seed)\n var_values = pstate.get_expression_variable_values_model(res, model)\n exp = pstate.actx.land([exp, res != sze])\n status, model = pstate.solve(exp)\n once_flag = True\n return res\np = Program(\"./4\")\ndse = SymbolicExplorator(Config(skip_unsupported_import=True,\\", "score": 0.7237749099731445 }, { "filename": "doc/practicals/solutions_toy_examples/solve0.py", "retrieved_chunk": "from tritondse import ProbeInterface, SymbolicExecutor, Config, Program, SymbolicExplorator, ProcessState, CbType, SeedStatus, Seed, SeedFormat, CompositeData\nfrom tritondse.types import Addr, SolverStatus, Architecture\nfrom tritondse.sanitizers import NullDerefSanitizer\nfrom triton import Instruction\ndef trace_inst(exec: SymbolicExecutor, pstate: ProcessState, inst: Instruction):\n print(f\"[tid:{inst.getThreadId()}] 0x{inst.getAddress():x}: {inst.getDisassembly()}\")\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"seed:{se.seed.hash} ({repr(se.seed.content)})\")\np = Program(\"./7\")\ndse = SymbolicExplorator(Config(\\", "score": 0.719312310218811 }, { "filename": "doc/practicals/solutions_toy_examples/solve3.py", "retrieved_chunk": " se.enqueue_seed(new_seed)\n target = pstate.evaluate_expression_model(lea, model)\n var_values = pstate.get_expression_variable_values_model(rax_sym, model)\n for var, value in var_values.items():\n print(f\"{var}: {chr(value)} Target = {hex(target)}\")\n exp = pstate.actx.land([exp, lea != target])\n status, model = pstate.solve(exp)\n once_flag_write = True\np = Program(\"./3\")\ndse = SymbolicExplorator(Config(\\", "score": 0.7100152969360352 }, { "filename": "doc/practicals/solutions_toy_examples/solve3.py", "retrieved_chunk": "from tritondse import ProbeInterface, SymbolicExecutor, Config, Program, SymbolicExplorator, ProcessState, CbType, SeedStatus, Seed, SeedFormat, CompositeData\nfrom tritondse.types import Addr, SolverStatus, Architecture\nfrom tritondse.sanitizers import NullDerefSanitizer\nfrom triton import Instruction\nonce_flag_write = False\nonce_flag_read = False\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"seed:{se.seed.hash} ({repr(se.seed.content)}) [exitcode:{se.exitcode}]\")\ndef memory_read_callback(se: SymbolicExecutor, pstate: ProcessState, addr):\n global once_flag_read", "score": 0.7032992839813232 } ]

[ { "filename": "doc/practicals/solutions_toy_examples/solve3.py", "retrieved_chunk": " se.enqueue_seed(new_seed)\n target = pstate.evaluate_expression_model(lea, model)\n var_values = pstate.get_expression_variable_values_model(rax_sym, model)\n for var, value in var_values.items():\n print(f\"{var}: {chr(value)} Target = {hex(target)}\")\n exp = pstate.actx.land([exp, lea != target])\n status, model = pstate.solve(exp)\n once_flag_write = True\np = Program(\"./3\")\ndse = SymbolicExplorator(Config(\\", "score": 0.8805747628211975 }, { "filename": "doc/practicals/solutions_toy_examples/solve2.py", "retrieved_chunk": " target = pstate.evaluate_expression_model(lea, model)\n var_values = pstate.get_expression_variable_values_model(rax_sym, model)\n for var, value in var_values.items():\n print(f\"{var}: {chr(value)} Target = {hex(target)}\")\n exp = pstate.actx.land([exp, lea != target])\n status, model = pstate.solve(exp)\n once_flag = True\np = Program(\"./2\")\nconf = Config(\\\n skip_unsupported_import=True, \\", "score": 0.8627632856369019 }, { "filename": "doc/practicals/solutions_toy_examples/solve5.py", "retrieved_chunk": " sze = pstate.evaluate_expression_model(res, model)\n new_seed = se.mk_new_seed_from_model(model)\n #print(f\"new_seed: {new_seed.content} len = {hex(sze)}\")\n se.enqueue_seed(new_seed)\n var_values = pstate.get_expression_variable_values_model(res, model)\n exp = pstate.actx.land([exp, res != sze])\n status, model = pstate.solve(exp)\n return\n if n_sym.isSymbolized():\n const = n_sym > buffer_len", "score": 0.830077052116394 }, { "filename": "doc/practicals/solutions_toy_examples/solve3.py", "retrieved_chunk": " se.enqueue_seed(new_seed)\n target = pstate.evaluate_expression_model(lea, model)\n var_values = pstate.get_expression_variable_values_model(rax_sym, model)\n for var, value in var_values.items():\n print(f\"{var}: {chr(value)} Target = {hex(target)}\")\n exp = pstate.actx.land([exp, lea != target])\n status, model = pstate.solve(exp)\n once_flag_read = True\n# 0010120f 89 54 85 80 MOV dword ptr [RBP + RAX*0x4 + -0x80],EDX\ndef memory_write_callback(se: SymbolicExecutor, pstate: ProcessState, addr, value):", "score": 0.8077747821807861 }, { "filename": "doc/practicals/solutions_toy_examples/solve6.py", "retrieved_chunk": " res = ast.bv(sze, 64)\n res = rec(res, s, 0, sze)\n pstate.push_constraint(pstate.read_symbolic_memory_byte(s+sze).getAst() == 0x00)\n # Manual state coverage of strlen(s) \n exp = res > n\n status, model = pstate.solve(exp)\n while status == SolverStatus.SAT:\n sze = pstate.evaluate_expression_model(res, model)\n new_seed = se.mk_new_seed_from_model(model)\n #print(f\"new_seed: {new_seed.content} len = {hex(sze)}\")", "score": 0.801544189453125 } ]

[ { "filename": "aiofauna/server.py", "retrieved_chunk": " else:\n response = func(*args, **kwargs, **definitive_args)\n return do_response(response)\n func.injectable = True\n wrapper._handler = func\n return wrapper\n return decorator\n def get(self, path: str, **kwargs):\n \"\"\"GET decorator\"\"\"\n def decorator(func):", "score": 0.7511000633239746 }, { "filename": "aiofauna/faunadb/query.py", "retrieved_chunk": " return _params({\"get\": ref_}, {\"ts\": ts})\ndef key_from_secret(secret):\n return _fn({\"key_from_secret\": secret})\ndef paginate(\n set, size=None, ts=None, after=None, before=None, events=None, sources=None\n):\n opts = {\n \"size\": size,\n \"ts\": ts,\n \"after\": after,", "score": 0.7451857328414917 }, { "filename": "aiofauna/odm.py", "retrieved_chunk": " )\n except (FaunaException, KeyError, TypeError, ValueError, Exception) as exc:\n cls.logger.error(exc.__class__.__name__)\n cls.logger.error(exc)\n raise exc\n @classmethod\n async def all(cls: Type[T], limit: int = 100, offset: int = 0) -> List[T]:\n try:\n _q = cls.q()\n query = q.paginate(q.match(q.index(f\"{cls.__name__.lower()}\")))", "score": 0.7440821528434753 }, { "filename": "aiofauna/faunadb/query.py", "retrieved_chunk": " \"before\": before,\n \"events\": events,\n \"sources\": sources,\n }\n return _params({\"paginate\": set}, opts)\ndef exists(ref_, ts=None):\n return _params({\"exists\": ref_}, {\"ts\": ts})\ndef create(collection_ref, params):\n return _fn({\"create\": collection_ref, \"params\": params})\ndef update(ref_, params):", "score": 0.7397210597991943 }, { "filename": "aiofauna/odm.py", "retrieved_chunk": " data = await self.__class__.q()(\n q.create(\n q.collection(self.__class__.__name__.lower()), {\"data\": self.dict()}\n )\n )\n self.ref = data[\"ref\"][\"@ref\"][\"id\"] # type: ignore\n self.ts = data[\"ts\"] / 1000 # type: ignore\n return self\n except (FaunaException, KeyError, TypeError, ValueError, Exception) as exc:\n self.logger.error(exc.__class__.__name__)", "score": 0.7381197810173035 } ]

[ { "filename": "doc/practicals/solutions_toy_examples/solve5.py", "retrieved_chunk": " buffer_len = pstate.get_argument_value(2)\n buffer_addr = pstate.get_argument_value(3)\n buffers_len_g[buffer_addr] = buffer_len\np = Program(\"./5\")\nalert_placeholder_addr = p.find_function_addr(\"__alert_placeholder\")\ndse = SymbolicExplorator(Config(skip_unsupported_import=True), p)\n#dse.add_input_seed(Seed(b\"AZERAZAZERA\"))\ndse.add_input_seed(Seed(b\"AZER\"))\ndse.callback_manager.register_probe(NullDerefSanitizer())\ndse.callback_manager.register_post_execution_callback(post_exec_hook)", "score": 0.8957525491714478 }, { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": " pstate.cpu.r0 = 1\n elif addr == STUB_ADDR2:\n pstate.cpu.r0 = 0\n pstate.cpu.program_counter += 2\n exec.skip_instruction()\ndef hook_start(exec: SymbolicExecutor, pstate: ProcessState):\n buffer = pstate.get_argument_value(0)\n length = pstate.get_argument_value(1)\n JSON_ctx = pstate.get_argument_value(2)\n exec.inject_symbolic_variable_memory(buffer, \"buffer\", exec.seed.content.variables[\"buffer\"])", "score": 0.8595215678215027 }, { "filename": "doc/practicals/solutions_toy_examples/solve5.py", "retrieved_chunk": " st, model = pstate.solve(const)\n if st == SolverStatus.SAT:\n new_seed = se.mk_new_seed_from_model(model)\n new_seed.status = SeedStatus.CRASH\n se.enqueue_seed(new_seed) \ndef trace_inst(exec: SymbolicExecutor, pstate: ProcessState, inst: Instruction):\n print(f\"[tid:{inst.getThreadId()}] 0x{inst.getAddress():x}: {inst.getDisassembly()}\")\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"seed:{se.seed.hash} ({repr(se.seed.content)}) [exitcode:{se.exitcode}]\")\ndef hook_alert_placeholder(exec: SymbolicExecutor, pstate: ProcessState, addr: int):", "score": 0.8261497020721436 }, { "filename": "doc/practicals/solution_json_parser.py", "retrieved_chunk": "def pre_inst(se: SymbolicExecutor, state: ProcessState, inst):\n if se.trace_offset > 40000:\n se.seed.status = SeedStatus.HANG\n se.abort()\n #print(f\"[{se.trace_offset}] {inst.getAddress():#08x}: {inst.getDisassembly()}\")\ndef post_exec_hook(se: SymbolicExecutor, state: ProcessState):\n print(f\"[{se.uid}] seed:{se.seed.hash} ({repr(se.seed.content.variables['buffer'][:100])}) => {se.seed.status.name} [exitcode:{se.exitcode}]\")\ndef fptr_stub(exec: SymbolicExecutor, pstate: ProcessState, addr: int):\n print(f\"fptr_stub addr : {addr:#x}\")\n if addr == STUB_ADDR1:", "score": 0.813831627368927 }, { "filename": "doc/practicals/solutions_toy_examples/solve1.py", "retrieved_chunk": " exec.inject_symbolic_input(arg, exec.seed)\n print(\"Symbolizing {} bytes at {}\".format(hex(sizeof), hex(arg)))\n s = pstate.memory.read_string(arg)\n print(f\"fread: {s}\")\n return 0\ndef hook_sscanf4(exec: SymbolicExecutor, pstate: ProcessState, routine: str, addr: int):\n # sscanf(buffer, \"%d\", &j) is treated as j = atoi(buffer)\n ast = pstate.actx\n addr_j = pstate.get_argument_value(2)\n arg = pstate.get_argument_value(0)", "score": 0.7755067944526672 } ]

[ { "filename": "aiofauna/utils.py", "retrieved_chunk": " \"\"\"\n async def wrapper(*args: Any, **kwargs: Any) -> T:\n \"\"\"\n Wrapper function to handle errors in the function call.\n \"\"\"\n try:\n logger.info(\"Calling %s\", func.__name__)\n return await func(*args, **kwargs)\n except HTTPException as exc:\n logger.error(exc.__class__.__name__)", "score": 0.8740904331207275 }, { "filename": "aiofauna/server.py", "retrieved_chunk": " else:\n response = func(*args, **kwargs, **definitive_args)\n return do_response(response)\n func.injectable = True\n wrapper._handler = func\n return wrapper\n return decorator\n def get(self, path: str, **kwargs):\n \"\"\"GET decorator\"\"\"\n def decorator(func):", "score": 0.8347190618515015 }, { "filename": "aiofauna/server.py", "retrieved_chunk": " return func\n return decorator\n def sse(self, path: str) -> Callable: # pylint: disable=invalid-name\n \"\"\"Server-Sent Events decorator\"\"\"\n def decorator(func: Callable) -> Callable:\n @wraps(func)\n async def wrapper(request: Request) -> EventSourceResponse:\n async with sse_response(request) as resp:\n args_to_apply = await load(\n request, signature(func).parameters.copy()", "score": 0.8179314732551575 }, { "filename": "aiofauna/client.py", "retrieved_chunk": " ) as exc: # pylint:disable=broad-exception-caught, unused-variable\n logger.error(exc)\n raise APIException(str(exc)) from exc\n async def text(self, url: str, method: Method = \"GET\", json: MaybeJson = None):\n session = await self.__load__()\n async with session.request(\n method, url, headers=self.headers, json=json\n ) as response:\n try:\n return await response.text()", "score": 0.8151251077651978 }, { "filename": "aiofauna/server.py", "retrieved_chunk": " \"\"\"Websocket decorator\"\"\"\n def decorator(func: Callable) -> Callable:\n @wraps(func)\n async def wrapper(request: Request):\n args_to_apply = await load(request, signature(func).parameters.copy())\n ws = WebSocketResponse()\n await ws.prepare(request)\n definitive_args = {}\n for name, param in signature(func).parameters.items():\n if param.annotation == WebSocketResponse:", "score": 0.8049793243408203 } ]

[ { "filename": "doc/practicals/solutions_toy_examples/solve4.py", "retrieved_chunk": " new_seed = se.mk_new_seed_from_model(model)\n print(f\"new_seed : {new_seed.content}\")\n se.enqueue_seed(new_seed)\n var_values = pstate.get_expression_variable_values_model(res, model)\n exp = pstate.actx.land([exp, res != sze])\n status, model = pstate.solve(exp)\n once_flag = True\n return res\np = Program(\"./4\")\ndse = SymbolicExplorator(Config(skip_unsupported_import=True,\\", "score": 0.8644561171531677 }, { "filename": "doc/practicals/solutions_toy_examples/solve2.py", "retrieved_chunk": " target = pstate.evaluate_expression_model(lea, model)\n var_values = pstate.get_expression_variable_values_model(rax_sym, model)\n for var, value in var_values.items():\n print(f\"{var}: {chr(value)} Target = {hex(target)}\")\n exp = pstate.actx.land([exp, lea != target])\n status, model = pstate.solve(exp)\n once_flag = True\np = Program(\"./2\")\nconf = Config(\\\n skip_unsupported_import=True, \\", "score": 0.8574234247207642 }, { "filename": "doc/practicals/solutions_toy_examples/solve5.py", "retrieved_chunk": " sze = pstate.evaluate_expression_model(res, model)\n new_seed = se.mk_new_seed_from_model(model)\n #print(f\"new_seed: {new_seed.content} len = {hex(sze)}\")\n se.enqueue_seed(new_seed)\n var_values = pstate.get_expression_variable_values_model(res, model)\n exp = pstate.actx.land([exp, res != sze])\n status, model = pstate.solve(exp)\n return\n if n_sym.isSymbolized():\n const = n_sym > buffer_len", "score": 0.7866446375846863 }, { "filename": "doc/practicals/solutions_toy_examples/solve2.py", "retrieved_chunk": " print(\"rax not symbolic\")\n return\n lea = addr.getLeaAst()\n if lea == None: return\n print(f\"argv[1] = {se.seed.content} Target = {hex(target)}\")\n exp = lea != target\n status, model = pstate.solve(exp)\n while status == SolverStatus.SAT:\n new_seed = se.mk_new_seed_from_model(model)\n se.enqueue_seed(new_seed)", "score": 0.7711276412010193 }, { "filename": "doc/practicals/solutions_toy_examples/solve6.py", "retrieved_chunk": " res = ast.bv(sze, 64)\n res = rec(res, s, 0, sze)\n pstate.push_constraint(pstate.read_symbolic_memory_byte(s+sze).getAst() == 0x00)\n # Manual state coverage of strlen(s) \n exp = res > n\n status, model = pstate.solve(exp)\n while status == SolverStatus.SAT:\n sze = pstate.evaluate_expression_model(res, model)\n new_seed = se.mk_new_seed_from_model(model)\n #print(f\"new_seed: {new_seed.content} len = {hex(sze)}\")", "score": 0.768902063369751 } ]

[ { "filename": "tritondse/loaders/loader.py", "retrieved_chunk": " def __init__(self, path: str):\n self.bin_path = Path(path)\n @property\n def name(self) -> str:\n \"\"\"\n Name of the loader and target being loaded.\n :return: str of the loader name\n \"\"\"\n raise NotImplementedError()\n @property", "score": 0.7923531532287598 }, { "filename": "tritondse/process_state.py", "retrieved_chunk": " :param value: value to set (default True)\n \"\"\"\n self.tt_ctx.setMode(mode, value)\n def set_thumb(self, enable: bool) -> None:\n \"\"\"\n Set thumb mode activated in the TritonContext. The mode will automatically\n be switched during execution, but at initialization this method enable\n activating it / disabling it. (Disabled be default)\n :param enable: bool: Wether or not to active thumb\n \"\"\"", "score": 0.7868510484695435 }, { "filename": "tritondse/memory.py", "retrieved_chunk": " :param name: Map name\n :return: MemMap if found\n \"\"\"\n l = []\n for map in (x for x in self._linear_map_map if x):\n if map.name == name:\n l.append(map)\n return l\n def map_from_name(self, name: str) -> MemMap:\n \"\"\"", "score": 0.7820653915405273 }, { "filename": "tritondse/process_state.py", "retrieved_chunk": " :param solver: Solver to use\n \"\"\"\n if isinstance(solver, str):\n solver = getattr(SOLVER, solver.upper(), SOLVER.Z3)\n self.tt_ctx.setSolver(solver)\n def _get_unique_thread_id(self) -> int:\n \"\"\"\n Return a new unique thread id. Used by thread related functions when spawning a new thread.\n :returns: new thread identifier\n \"\"\"", "score": 0.7780481576919556 }, { "filename": "tritondse/worklist.py", "retrieved_chunk": " \"\"\"\n raise NotImplementedError()\n def add(self, seed: Seed) -> None:\n \"\"\"\n Add a new seed in the scheduler\n :param seed: Seed to add in the scheduler\n :type seed: Seed\n \"\"\"\n raise NotImplementedError()\n def update_worklist(self, coverage: GlobalCoverage) -> None:", "score": 0.7771698236465454 } ]

[ { "filename": "aiofauna/server.py", "retrieved_chunk": " else:\n response = func(*args, **kwargs, **definitive_args)\n return do_response(response)\n func.injectable = True\n wrapper._handler = func\n return wrapper\n return decorator\n def get(self, path: str, **kwargs):\n \"\"\"GET decorator\"\"\"\n def decorator(func):", "score": 0.7653361558914185 }, { "filename": "aiofauna/odm.py", "retrieved_chunk": " )\n except (FaunaException, KeyError, TypeError, ValueError, Exception) as exc:\n cls.logger.error(exc.__class__.__name__)\n cls.logger.error(exc)\n raise exc\n @classmethod\n async def all(cls: Type[T], limit: int = 100, offset: int = 0) -> List[T]:\n try:\n _q = cls.q()\n query = q.paginate(q.match(q.index(f\"{cls.__name__.lower()}\")))", "score": 0.7532316446304321 }, { "filename": "aiofauna/faunadb/query.py", "retrieved_chunk": " return _params({\"get\": ref_}, {\"ts\": ts})\ndef key_from_secret(secret):\n return _fn({\"key_from_secret\": secret})\ndef paginate(\n set, size=None, ts=None, after=None, before=None, events=None, sources=None\n):\n opts = {\n \"size\": size,\n \"ts\": ts,\n \"after\": after,", "score": 0.7504632472991943 }, { "filename": "aiofauna/server.py", "retrieved_chunk": " params = sig.parameters\n open_api_params = extract(params.copy(), path)\n self._route_open_api_params[(path, method)] = open_api_params\n transform(self.openapi, path, method, func, open_api_params)\n async def wrapper(*args, **kwargs):\n request: Request = args[0]\n args = args[1:]\n args_to_apply = await load(request, params.copy())\n definitive_args = {}\n for name, param in params.items():", "score": 0.7431697845458984 }, { "filename": "aiofauna/odm.py", "retrieved_chunk": " self.logger.error(exc)\n raise exc\n @classmethod\n async def update(cls: Type[T], ref: str, **kwargs: Any) -> T:\n try:\n instance = await cls.q()(\n q.update(\n q.ref(q.collection(cls.__name__.lower()), ref),\n {\"data\": kwargs.get(\"kwargs\", kwargs)},\n )", "score": 0.7428878545761108 } ]

[ { "filename": "tritondse/workspace.py", "retrieved_chunk": " elif isinstance(content, bytes):\n p.write_bytes(content)\n else:\n assert False\n @property\n def logfile_path(self):\n return self.root_dir / self.LOG_FILE", "score": 0.7239226698875427 }, { "filename": "tritondse/config.py", "retrieved_chunk": " \"\"\"\n Save the current configuration to a file\n :param file: The path name\n \"\"\"\n with open(file, \"w\") as f:\n f.write(self.to_json())\n @staticmethod\n def from_file(file: str) -> 'Config':\n \"\"\"\n Load a configuration from a file to a new instance of Config", "score": 0.7188020348548889 }, { "filename": "tritondse/config.py", "retrieved_chunk": " \"\"\" This option defines whether or not memory segmentation is enforced.\n If activated all memory accesses must belong to a mapped memory area.\n \"\"\"\n self.custom = {}\n \"\"\"\n Custom carrier field enabling user to add parameters of their own.\n \"\"\"\n def __str__(self):\n return \"\\n\".join(f\"{k.ljust(23)}= {v}\" for k, v in self.__dict__.items())\n def to_file(self, file: str) -> None:", "score": 0.6940771341323853 }, { "filename": "tritondse/workspace.py", "retrieved_chunk": " def save_metadata_file(self, name: str, content: Union[str, bytes]) -> None:\n \"\"\"\n Save ``content`` in a file ``name`` in the metadata directory.\n The name should be a file name not a path.\n :param name: file name\n :type name: str\n :param content: content of the file to write\n :type content: Union[str, bytes]\n \"\"\"\n p = (self.root_dir / self.METADATA_DIR) / name", "score": 0.6932335495948792 }, { "filename": "tritondse/workspace.py", "retrieved_chunk": " except:\n logger.warning(f\"seed {seed} unlink failed\")\n pass # FIXME: Not meant to get here\n self.save_seed(seed)\n def save_file(self, rel_path: PathLike, content: Union[str, bytes], override: bool = False):\n \"\"\"\n Save a, arbitrary file in the workspace by providing the relative path\n of the file. If ``override`` is True, erase the previous file if any.\n :param rel_path: relative path of the file\n :type rel_path: :py:obj:`tritondse.types.PathLike`", "score": 0.6872227191925049 } ]

[ { "filename": "aiofauna/faunadb/objects.py", "retrieved_chunk": " Ref(id, cls=None, db=None)\n ```\n A reference to a document in a collection or index.\n :param id: The document's ID.\n :param cls: The collection or index class.\n :param db: The database.\n `Ref`\n Is a special type in FaunaDB. It is used to represent a document in a collection or index.\n It is serialized to JSON as an object with the `@ref` key. Passing the `id` to the response.\n \"\"\"", "score": 0.845402181148529 }, { "filename": "aiofauna/docs.py", "retrieved_chunk": " Extract OpenAPI parameters from the function parameters.\n Args:\n params (dict): The parameters of the function.\n path (str): The URL path of the endpoint.\n Returns:\n Dict[str, Any]: The extracted OpenAPI parameters.\n \"\"\"\n open_api_params = {}\n for name, param in params.items():\n type_ = param.annotation", "score": 0.8255933523178101 }, { "filename": "aiofauna/llm/llm.py", "retrieved_chunk": " Arguments:\n text -- Input text for the function\n context -- Optional context for the function\n model -- Model to be used. Defaults to \"gpt-4-0613\"\n functions -- List of function types. Defaults to all subclasses of FunctionType.\n \"\"\"\n if context is not None:\n messages = [\n {\"role\": \"user\", \"content\": text},\n {\"role\": \"system\", \"content\": context},", "score": 0.8126949071884155 }, { "filename": "aiofauna/docs.py", "retrieved_chunk": " \"description\": func.__doc__,\n \"parameters\": _scalars,\n \"responses\": {\"200\": {\"description\": \"OK\"}},\n }\nasync def load(request: Request, params: dict):\n \"\"\"\n Shape the endpoint function parameters to match the request.\n Args:\n request (Request): The HTTP request.\n params (dict): The parameters of the function.", "score": 0.8120658993721008 }, { "filename": "aiofauna/json.py", "retrieved_chunk": " *,\n include: List[str] = [],\n exclude: List[str] = [],\n by_alias: bool = False,\n skip_defaults: bool = False,\n custom_encoder: Any = None,\n) -> Any:\n \"\"\"\n Convert any object to a JSON-serializable object.\n This function is used by Aiofauna to convert objects to JSON-serializable objects.", "score": 0.8103455305099487 } ]