Datasets:

---

tianyang

/

repobench_python_v1.1

like 7

[ { "identifier": "ProjectHandler", "path": "codeinsight_sdk/handlers.py", "snippet": "class ProjectHandler(Handler):\n def __init__(self, client):\n super().__init__(client)\n self.cls = Project\n\n def create(self, name:str, description:str = None, folder:str = None,\n scanProfileName:str = None,\n owner:str = None,\n risk:str = None,\n folderId:int = None,\n customFields:List[dict] = None,\n ) -> int:\n \"\"\"\n Creates a project.\n\n Args:\n name (str): The name of the project.\n description (str, optional): The description of the project. Defaults to None.\n folder (str, optional): The folder of the project. Defaults to None.\n\n Returns:\n Project: The created project id.\n \"\"\"\n path = \"projects\"\n data = {\"name\": name,\n \"description\": description,\n \"folderName\": folder,\n \"scanProfileName\": scanProfileName,\n \"owner\": owner,\n \"risk\": risk,\n \"folderId\": folderId,\n \"customFields\": customFields}\n resp = self.client.request(\"POST\", url_part=path, body=data)\n try:\n project_id = resp.json()['data']['id']\n except KeyError:\n raise CodeInsightError(resp)\n return project_id\n\n\n #Note API endpoints switch between projects and project...\n def all(self) -> List[Project]:\n \"\"\"\n Retrieves all projects from the server.\n\n Returns:\n A list of Project objects representing all the projects.\n \"\"\"\n\n path = \"projects\"\n resp = self.client.request(\"GET\", url_part=path)\n projects = []\n for project_data in resp.json()['data']:\n projects.append(self.cls.from_dict(project_data))\n return projects\n \n def get(self, id:int) -> Project:\n \"\"\"\n Retrieves a project by its ID.\n\n Args:\n id (int): The ID of the project requested.\n\n Returns:\n Project: The retrieved project.\n \"\"\"\n path = f\"projects/{id}\"\n resp = self.client.request(\"GET\", url_part=path)\n project_data = resp.json()['data']\n return self.cls.from_dict(project_data)\n \n def get_id(self, project_name:str) -> int:\n \"\"\"\n Retrieves the ID of a project based on its name.\n\n Args:\n projectName (str): The name of the project.\n\n Returns:\n int: The ID of the project.\n \"\"\"\n path = \"project/id\"\n params = {\"projectName\": project_name}\n resp = self.client.request(\"GET\", url_part=path, params=params)\n try:\n project_id = resp.json()['Content: '] # Yes, the key is called 'Content: ' ...\n except KeyError:\n raise CodeInsightError(resp)\n return project_id\n\n def get_inventory_summary(self, project_id:int,\n vulnerabilitySummary : bool = False,\n cvssVersion: str = 'ANY',\n published: str = 'ALL',\n offset:int = 1,\n limit:int = 25) -> List[ProjectInventoryItem]:\n \"\"\"\n Retrieves the inventory summary for a specific project.\n\n Args:\n project_id (int): The ID of the project.\n vulnerabilitySummary (bool, optional): Flag to include vulnerability summary. Defaults to False.\n cvssVersion (str, optional): The CVSS version to filter vulnerabilities. Defaults to 'ANY'.\n published (str, optional): The publication status. Defaults to 'ALL'.\n offset (int, optional): The offset for pagination. Defaults to 1.\n limit (int, optional): The maximum number of items to return. Defaults to 25.\n\n Returns:\n List[ProjectInventoryItem]: A list of ProjectInventoryItem objects representing the inventory summary.\n \"\"\"\n path = f\"projects/{project_id}/inventorySummary\"\n params = {\"vulnerabilitySummary\": vulnerabilitySummary,\n \"cvssVersion\": cvssVersion,\n \"published\": published,\n \"offset\": offset,\n \"limit\": limit \n }\n resp = self.client.request(\"GET\", url_part=path, params=params)\n current_page = int(resp.headers['current-page'])\n number_of_pages = int(resp.headers['number-of-pages'])\n total_records = int(resp.headers['total-records'])\n inventory = []\n for inv_item in resp.json()['data']:\n inventory.append(ProjectInventoryItem.from_dict(inv_item))\n \n # Iterate through all the pages\n if number_of_pages > offset:\n params.update({\"offset\": offset+1})\n chunk = self.get_inventory_summary(project_id, **params)\n # Only append the inventory records\n inventory.extend(chunk)\n return inventory\n \n def get_inventory(self,project_id:int,\n skip_vulnerabilities: bool = False,\n published:bool = True,\n vendor:str = None,\n product:str = None,\n page_size: int = 100,\n page: int = 1,\n review_status: str = None,\n alerts: str = None,\n include_files: bool = True\n ) -> ProjectInventory:\n path = f\"project/inventory/{project_id}\"\n params = {\"skipVulnerabilities\": skip_vulnerabilities,\n \"published\": published,\n \"vendor\": vendor,\n \"product\": product,\n \"page\": page,\n \"pageSize\": page_size,\n \"reviewStatus\": review_status,\n \"alerts\": alerts,\n \"includeFiles\": include_files}\n\n resp = self.client.request(\"GET\", url_part=path, params=params)\n project_inventory = resp.json()\n project = ProjectInventory.from_dict(project_inventory)\n\n # Iterate through all the pages\n if int(resp.headers['number-of-pages']) > page:\n chunk = self.get_inventory(project_id, page=page+1)\n # Only append the inventory records\n project.inventoryItems.extend(chunk.inventoryItems)\n\n return project" }, { "identifier": "Handler", "path": "codeinsight_sdk/handlers.py", "snippet": "class Handler(abc.ABC):\n def __init__(self, client):\n self.client = client\n self.cls = None\n \n @staticmethod\n def create(client, cls):\n k = cls.__name__\n handlers = {\"Project\": ProjectHandler,\n \"Report\": ReportHandler\n }\n handler = handlers.get(k)\n if handler is None:\n raise ValueError(f\"Handler not found for class '{k}'\")\n return handler(client)\n \n @abc.abstractmethod\n def get(self):\n pass" }, { "identifier": "ReportHandler", "path": "codeinsight_sdk/handlers.py", "snippet": "class ReportHandler(Handler):\n \"\"\"\n A class that handles operations related to reports.\n\n Args:\n client (Client): The client object used for making API requests.\n\n Attributes:\n cls (Report): The class representing a report.\n\n Methods:\n get(id): Retrieves a report by its ID.\n all(): Retrieves all reports.\n\n \"\"\"\n\n def __init__(self, client):\n super().__init__(client)\n self.cls = Report\n\n def get(self, id:int):\n \"\"\"\n Retrieves a report by its ID.\n\n Args:\n id (int): The ID of the report to retrieve.\n\n Returns:\n Report: The report object.\n\n \"\"\"\n path = f\"reports/{id}\"\n resp = self.client.request(\"GET\", url_part=path)\n report_data = resp.json()['data']\n report = self.cls.from_dict(report_data)\n return report\n\n def all(self):\n \"\"\"\n Retrieves all reports.\n\n Returns:\n list: A list of report objects.\n\n \"\"\"\n path = \"reports\"\n resp = self.client.request(\"GET\", url_part=path)\n reports = []\n for report_data in resp.json()['data']:\n reports.append(self.cls.from_dict(report_data))\n return reports" }, { "identifier": "Project", "path": "codeinsight_sdk/models.py", "snippet": "class Project(DataClassJsonMixin):\n id: int\n name: str\n status: Optional[str] = None\n owner: Optional[str] = None\n description: Optional[str] = None\n dateCreated: Optional[str] = None\n projectPath: Optional[str] = None\n # TODO: Should this be a dictionary or another class? This structure is reused in a few APIs\n vulnerabilities: Optional[Dict[str, Dict]] = None" }, { "identifier": "ProjectInventory", "path": "codeinsight_sdk/models.py", "snippet": "class ProjectInventory():\n projectId: int\n inventoryItems: List[ProjectInventoryItem]" }, { "identifier": "Report", "path": "codeinsight_sdk/models.py", "snippet": "class Report(DataClassJsonMixin):\n id: int\n name: str\n path: str\n default: bool\n enabled: bool\n enableProjectPicker: bool\n order: int\n createdDateTime: str\n updatedDateTime: str" }, { "identifier": "CodeInsightError", "path": "codeinsight_sdk/exceptions.py", "snippet": "class CodeInsightError(GenericError):\n \"\"\"Error class for code insight API errors.\"\"\"\n def __init__(self, response: requests.Response):\n try:\n resp = response.json()\n self.code = response.status_code\n self.message = resp['Error: ']\n self.arguments = resp['Arguments: ']\n self.error = resp['Key: ']\n self.add_note(f\"Arguments: {self.arguments}\")\n super().__init__(\"Error: %s - %s\" % (self.code, self.message))\n\n except KeyError:\n raise ValueError(f\"Error parsing response: {resp}\")\n except json.decoder.JSONDecodeError:\n raise ValueError(f\"Error decoding response: {resp}\")" } ]

[ { "identifier": "commons", "path": "rvc_python/lib/infer_pack/commons.py", "snippet": "def init_weights(m, mean=0.0, std=0.01):\ndef get_padding(kernel_size, dilation=1):\ndef convert_pad_shape(pad_shape):\ndef kl_divergence(m_p, logs_p, m_q, logs_q):\ndef rand_gumbel(shape):\ndef rand_gumbel_like(x):\ndef slice_segments(x, ids_str, segment_size=4):\ndef slice_segments2(x, ids_str, segment_size=4):\ndef rand_slice_segments(x, x_lengths=None, segment_size=4):\ndef get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):\ndef add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):\ndef cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):\ndef subsequent_mask(length):\ndef fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):\ndef convert_pad_shape(pad_shape):\ndef shift_1d(x):\ndef sequence_mask(length, max_length=None):\ndef generate_path(duration, mask):\ndef clip_grad_value_(parameters, clip_value, norm_type=2):" }, { "identifier": "init_weights", "path": "rvc_python/lib/infer_pack/commons.py", "snippet": "def init_weights(m, mean=0.0, std=0.01):\n classname = m.__class__.__name__\n if classname.find(\"Conv\") != -1:\n m.weight.data.normal_(mean, std)" }, { "identifier": "get_padding", "path": "rvc_python/lib/infer_pack/commons.py", "snippet": "def get_padding(kernel_size, dilation=1):\n return int((kernel_size * dilation - dilation) / 2)" }, { "identifier": "piecewise_rational_quadratic_transform", "path": "rvc_python/lib/infer_pack/transforms.py", "snippet": "def piecewise_rational_quadratic_transform(\n inputs,\n unnormalized_widths,\n unnormalized_heights,\n unnormalized_derivatives,\n inverse=False,\n tails=None,\n tail_bound=1.0,\n min_bin_width=DEFAULT_MIN_BIN_WIDTH,\n min_bin_height=DEFAULT_MIN_BIN_HEIGHT,\n min_derivative=DEFAULT_MIN_DERIVATIVE,\n):\n if tails is None:\n spline_fn = rational_quadratic_spline\n spline_kwargs = {}\n else:\n spline_fn = unconstrained_rational_quadratic_spline\n spline_kwargs = {\"tails\": tails, \"tail_bound\": tail_bound}\n\n outputs, logabsdet = spline_fn(\n inputs=inputs,\n unnormalized_widths=unnormalized_widths,\n unnormalized_heights=unnormalized_heights,\n unnormalized_derivatives=unnormalized_derivatives,\n inverse=inverse,\n min_bin_width=min_bin_width,\n min_bin_height=min_bin_height,\n min_derivative=min_derivative,\n **spline_kwargs\n )\n return outputs, logabsdet" } ]

[ { "identifier": "UpdateImage", "path": "remarkable_update_fuse/image.py", "snippet": "class UpdateImage(io.RawIOBase):\n _manifest = None\n _offset = -1\n _size = 0\n _pos = 0\n\n def __init__(self, update_file, cache_size=500, cache_ttl=60):\n self.update_file = update_file\n self.cache_size = cache_size\n self._cache = BlockCache(\n maxsize=cache_size * 1024 * 1024,\n ttl=cache_ttl,\n )\n with open(self.update_file, \"rb\") as f:\n magic = f.read(4)\n if magic != b\"CrAU\":\n raise UpdateImageException(\"Wrong header\")\n\n major = struct.unpack(\">Q\", f.read(8))[0]\n if major != 1:\n raise UpdateImageException(\"Unsupported version\")\n\n size = struct.unpack(\">Q\", f.read(8))[0]\n data = f.read(size)\n self._manifest = DeltaArchiveManifest.FromString(data)\n self._offset = f.tell()\n\n for blob, offset, length, f in self._blobs:\n self._size += length\n\n def verify(self, publickey):\n _publickey = load_pem_public_key(publickey)\n with open(self.update_file, \"rb\") as f:\n data = f.read(self._offset + self._manifest.signatures_offset)\n\n actual_hash = sha256(data).digest()\n signed_hash = _publickey.recover_data_from_signature(\n self.signature,\n PKCS1v15(),\n SHA256,\n )\n if actual_hash != signed_hash:\n raise UpdateImageSignatureException(\n \"Actual hash does not match signed hash\", signed_hash, actual_hash\n )\n\n @property\n def block_size(self):\n return self._manifest.block_size\n\n @property\n def signature(self):\n for signature in self._signatures:\n if signature.version == 2:\n return signature.data\n\n return None\n\n @property\n def _signatures(self):\n with open(self.update_file, \"rb\") as f:\n f.seek(self._offset + self._manifest.signatures_offset)\n for signature in Signatures.FromString(\n f.read(self._manifest.signatures_size)\n ).signatures:\n yield signature\n\n @property\n def _blobs(self):\n with open(self.update_file, \"rb\") as f:\n for blob in self._manifest.partition_operations:\n f.seek(self._offset + blob.data_offset)\n dst_offset = blob.dst_extents[0].start_block * self.block_size\n dst_length = blob.dst_extents[0].num_blocks * self.block_size\n if blob.type not in (0, 1):\n raise UpdateImageException(f\"Unsupported type {blob.type}\")\n\n yield blob, dst_offset, dst_length, f\n\n self.expire()\n\n def _read_blob(self, blob, blob_offset, blob_length, f):\n if blob_offset in self._cache:\n return self._cache[blob_offset]\n\n if blob.type not in (\n InstallOperation.Type.REPLACE,\n InstallOperation.Type.REPLACE_BZ,\n ):\n raise NotImplementedError(\n f\"Error: {InstallOperation.Type.keys()[blob.type]} has not been implemented yet\"\n )\n\n blob_data = f.read(blob.data_length)\n if sha256(blob_data).digest() != blob.data_sha256_hash:\n raise UpdateImageException(\"Error: Data has wrong sha256sum\")\n\n if blob.type == InstallOperation.Type.REPLACE_BZ:\n try:\n blob_data = bz2.decompress(blob_data)\n\n except ValueError as err:\n raise UpdateImageException(f\"Error: {err}\") from err\n\n if blob_length - len(blob_data) < 0:\n raise UpdateImageException(\n f\"Error: Bz2 compressed data was the wrong length {len(blob_data)}\"\n )\n\n try:\n self._cache[blob_offset] = blob_data\n except ValueError as err:\n if str(err) != \"value too large\":\n raise err\n\n return blob_data\n\n @property\n def cache(self):\n return self._cache\n\n @property\n def size(self):\n return self._size\n\n def expire(self):\n self._cache.expire()\n\n def writable(self):\n return False\n\n def seekable(self):\n return False\n\n def readable(self):\n return True\n\n def seek(self, offset, whence=os.SEEK_SET):\n if whence not in (os.SEEK_SET, os.SEEK_CUR, os.SEEK_END):\n raise OSError(\"Not supported whence\")\n if whence == os.SEEK_SET and offset < 0:\n raise ValueError(\"offset can't be negative\")\n if whence == os.SEEK_END and offset > 0:\n raise ValueError(\"offset can't be positive\")\n\n if whence == os.SEEK_SET:\n self._pos = min(max(offset, 0), self._size)\n elif whence == os.SEEK_CUR:\n self._pos = min(max(self._pos + offset, 0), self._size)\n elif whence == os.SEEK_END:\n self._pos = min(max(self._pos + offset + self._size, 0), self._size)\n return self._pos\n\n def tell(self):\n return self._pos\n\n def read(self, size=-1):\n res = self.peek(size)\n self.seek(len(res), whence=os.SEEK_CUR)\n return res\n\n def peek(self, size=0):\n offset = self._pos\n if offset >= self._size:\n return b\"\"\n\n if size <= 0 or offset + size > self._size:\n size = self._size - offset\n\n res = bytearray(size)\n for blob, blob_offset, blob_length, f in self._blobs:\n if offset < blob_offset:\n continue\n if offset >= blob_offset + blob_length:\n continue\n\n blob_data = self._read_blob(blob, blob_offset, blob_length, f)\n blob_start_offset = max(offset - blob_offset, 0)\n blob_end_offset = min(offset - blob_offset + size, blob_length)\n data = blob_data[blob_start_offset:blob_end_offset]\n\n assert blob_start_offset >= 0\n assert blob_end_offset <= blob_length\n assert blob_end_offset - blob_start_offset == len(data)\n\n start_offset = blob_offset + blob_start_offset - offset\n end_offset = blob_offset + blob_end_offset - offset\n res[start_offset:end_offset] = data\n\n assert start_offset >= 0\n assert start_offset < len(res)\n assert end_offset < blob_offset + blob_length\n assert end_offset - start_offset == len(data)\n assert end_offset <= len(res)\n assert res[start_offset:end_offset] == data\n\n assert len(res) == size\n return bytes(res)" }, { "identifier": "UpdateImageSignatureException", "path": "remarkable_update_fuse/image.py", "snippet": "class UpdateImageSignatureException(UpdateImageException):\n def __init__(self, message, signed_hash, actual_hash):\n super().__init__(self, message)\n self.signed_hash = signed_hash\n self.actual_hash = actual_hash" }, { "identifier": "KillableThread", "path": "remarkable_update_fuse/threads.py", "snippet": "class KillableThread(threading.Thread):\n def run(self):\n try:\n super().run()\n\n except SystemExit:\n pass\n\n def kill(self):\n if not self.is_alive():\n return\n\n res = ctypes.pythonapi.PyThreadState_SetAsyncExc(\n ctypes.c_ulong(self.ident),\n ctypes.py_object(SystemExit),\n )\n\n if res == 0:\n raise ValueError(f\"Invalid thread id: {self.ident}\")\n\n if res == 1:\n return\n\n # \"if it returns a number greater than one, you're in trouble,\n # and you should call it again with exc=NULL to revert the effect\"\n ctypes.pythonapi.PyThreadState_SetAsyncExc(\n ctypes.c_ulong(self.ident),\n None,\n )\n raise SystemError(\"PyThreadState_SetAsyncExc failed\")" } ]

[ { "identifier": "load_data", "path": "core/utils.py", "snippet": "def load_data(\n file_names: Optional[List[str]] = None,\n directory: Optional[str] = None,\n urls: Optional[List[str]] = None,\n) -> List[Document]:\n \"\"\"Load data.\"\"\"\n file_names = file_names or []\n directory = directory or \"\"\n urls = urls or []\n\n # get number depending on whether specified\n num_specified = sum(1 for v in [file_names, urls, directory] if v)\n\n if num_specified == 0:\n raise ValueError(\"Must specify either file_names or urls or directory.\")\n elif num_specified > 1:\n raise ValueError(\"Must specify only one of file_names or urls or directory.\")\n elif file_names:\n reader = SimpleDirectoryReader(input_files=file_names)\n docs = reader.load_data()\n elif directory:\n reader = SimpleDirectoryReader(input_dir=directory)\n docs = reader.load_data()\n elif urls:\n from llama_hub.web.simple_web.base import SimpleWebPageReader\n\n # use simple web page reader from llamahub\n loader = SimpleWebPageReader()\n docs = loader.load_data(urls=urls)\n else:\n raise ValueError(\"Must specify either file_names or urls or directory.\")\n\n return docs" }, { "identifier": "get_tool_objects", "path": "core/utils.py", "snippet": "def get_tool_objects(tool_names: List[str]) -> List:\n \"\"\"Get tool objects from tool names.\"\"\"\n # construct additional tools\n tool_objs = []\n for tool_name in tool_names:\n if tool_name == \"web_search\":\n # build web agent\n tool_objs.append(get_web_agent_tool())\n else:\n raise ValueError(f\"Tool {tool_name} not recognized.\")\n\n return tool_objs" }, { "identifier": "construct_agent", "path": "core/utils.py", "snippet": "def construct_agent(\n system_prompt: str,\n rag_params: RAGParams,\n docs: List[Document],\n vector_index: Optional[VectorStoreIndex] = None,\n additional_tools: Optional[List] = None,\n) -> Tuple[BaseChatEngine, Dict]:\n \"\"\"Construct agent from docs / parameters / indices.\"\"\"\n extra_info = {}\n additional_tools = additional_tools or []\n\n # first resolve llm and embedding model\n embed_model = resolve_embed_model(rag_params.embed_model)\n # llm = resolve_llm(rag_params.llm)\n # TODO: use OpenAI for now\n # llm = OpenAI(model=rag_params.llm)\n llm = _resolve_llm(rag_params.llm)\n\n # first let's index the data with the right parameters\n service_context = ServiceContext.from_defaults(\n chunk_size=rag_params.chunk_size,\n llm=llm,\n embed_model=embed_model,\n )\n\n if vector_index is None:\n vector_index = VectorStoreIndex.from_documents(\n docs, service_context=service_context\n )\n else:\n pass\n\n extra_info[\"vector_index\"] = vector_index\n\n vector_query_engine = vector_index.as_query_engine(\n similarity_top_k=rag_params.top_k\n )\n all_tools = []\n vector_tool = QueryEngineTool(\n query_engine=vector_query_engine,\n metadata=ToolMetadata(\n name=\"vector_tool\",\n description=(\"Use this tool to answer any user question over any data.\"),\n ),\n )\n all_tools.append(vector_tool)\n if rag_params.include_summarization:\n summary_index = SummaryIndex.from_documents(\n docs, service_context=service_context\n )\n summary_query_engine = summary_index.as_query_engine()\n summary_tool = QueryEngineTool(\n query_engine=summary_query_engine,\n metadata=ToolMetadata(\n name=\"summary_tool\",\n description=(\n \"Use this tool for any user questions that ask \"\n \"for a summarization of content\"\n ),\n ),\n )\n all_tools.append(summary_tool)\n\n # then we add tools\n all_tools.extend(additional_tools)\n\n # build agent\n if system_prompt is None:\n return \"System prompt not set yet. Please set system prompt first.\"\n\n agent = load_agent(\n all_tools,\n llm=llm,\n system_prompt=system_prompt,\n verbose=True,\n extra_kwargs={\"vector_index\": vector_index, \"rag_params\": rag_params},\n )\n return agent, extra_info" }, { "identifier": "RAGParams", "path": "core/utils.py", "snippet": "class RAGParams(BaseModel):\n \"\"\"RAG parameters.\n\n Parameters used to configure a RAG pipeline.\n\n \"\"\"\n\n include_summarization: bool = Field(\n default=False,\n description=(\n \"Whether to include summarization in the RAG pipeline. (only for GPT-4)\"\n ),\n )\n top_k: int = Field(\n default=2, description=\"Number of documents to retrieve from vector store.\"\n )\n chunk_size: int = Field(default=1024, description=\"Chunk size for vector store.\")\n embed_model: str = Field(\n default=\"default\", description=\"Embedding model to use (default is OpenAI)\"\n )\n llm: str = Field(\n default=\"gpt-4-1106-preview\", description=\"LLM to use for summarization.\"\n )" }, { "identifier": "construct_mm_agent", "path": "core/utils.py", "snippet": "def construct_mm_agent(\n system_prompt: str,\n rag_params: RAGParams,\n docs: List[Document],\n mm_vector_index: Optional[VectorStoreIndex] = None,\n additional_tools: Optional[List] = None,\n) -> Tuple[BaseChatEngine, Dict]:\n \"\"\"Construct agent from docs / parameters / indices.\n\n NOTE: system prompt isn't used right now\n\n \"\"\"\n extra_info = {}\n additional_tools = additional_tools or []\n\n # first resolve llm and embedding model\n embed_model = resolve_embed_model(rag_params.embed_model)\n # TODO: use OpenAI for now\n os.environ[\"OPENAI_API_KEY\"] = st.secrets.openai_key\n openai_mm_llm = OpenAIMultiModal(model=\"gpt-4-vision-preview\", max_new_tokens=1500)\n\n # first let's index the data with the right parameters\n service_context = ServiceContext.from_defaults(\n chunk_size=rag_params.chunk_size,\n embed_model=embed_model,\n )\n\n if mm_vector_index is None:\n mm_vector_index = MultiModalVectorStoreIndex.from_documents(\n docs, service_context=service_context\n )\n else:\n pass\n\n mm_retriever = mm_vector_index.as_retriever(similarity_top_k=rag_params.top_k)\n mm_query_engine = SimpleMultiModalQueryEngine(\n cast(MultiModalVectorIndexRetriever, mm_retriever),\n multi_modal_llm=openai_mm_llm,\n )\n\n extra_info[\"vector_index\"] = mm_vector_index\n\n # use condense + context chat engine\n agent = MultimodalChatEngine(mm_query_engine)\n\n return agent, extra_info" } ]

[ { "identifier": "TransformerEncoder", "path": "modules/naturalpseech2/transformers.py", "snippet": "class TransformerEncoder(nn.Module):\n def __init__(\n self,\n enc_emb_tokens=None,\n encoder_layer=None,\n encoder_hidden=None,\n encoder_head=None,\n conv_filter_size=None,\n conv_kernel_size=None,\n encoder_dropout=None,\n use_cln=None,\n cfg=None,\n ):\n super().__init__()\n\n self.encoder_layer = (\n encoder_layer if encoder_layer is not None else cfg.encoder_layer\n )\n self.encoder_hidden = (\n encoder_hidden if encoder_hidden is not None else cfg.encoder_hidden\n )\n self.encoder_head = (\n encoder_head if encoder_head is not None else cfg.encoder_head\n )\n self.conv_filter_size = (\n conv_filter_size if conv_filter_size is not None else cfg.conv_filter_size\n )\n self.conv_kernel_size = (\n conv_kernel_size if conv_kernel_size is not None else cfg.conv_kernel_size\n )\n self.encoder_dropout = (\n encoder_dropout if encoder_dropout is not None else cfg.encoder_dropout\n )\n self.use_cln = use_cln if use_cln is not None else cfg.use_cln\n\n if enc_emb_tokens != None:\n self.use_enc_emb = True\n self.enc_emb_tokens = enc_emb_tokens\n else:\n self.use_enc_emb = False\n\n self.position_emb = PositionalEncoding(\n self.encoder_hidden, self.encoder_dropout\n )\n\n self.layers = nn.ModuleList([])\n self.layers.extend(\n [\n TransformerEncoderLayer(\n self.encoder_hidden,\n self.encoder_head,\n self.conv_filter_size,\n self.conv_kernel_size,\n self.encoder_dropout,\n self.use_cln,\n )\n for i in range(self.encoder_layer)\n ]\n )\n\n if self.use_cln:\n self.last_ln = StyleAdaptiveLayerNorm(self.encoder_hidden)\n else:\n self.last_ln = nn.LayerNorm(self.encoder_hidden)\n\n def forward(self, x, key_padding_mask, condition=None):\n if len(x.shape) == 2 and self.use_enc_emb:\n x = self.enc_emb_tokens(x)\n x = self.position_emb(x)\n else:\n x = self.position_emb(x) # (B, T, d)\n\n for layer in self.layers:\n x = layer(x, key_padding_mask, condition)\n\n if self.use_cln:\n x = self.last_ln(x, condition)\n else:\n x = self.last_ln(x)\n\n return x" }, { "identifier": "DurationPredictor", "path": "modules/naturalpseech2/transformers.py", "snippet": "class DurationPredictor(nn.Module):\n def __init__(self, cfg):\n super().__init__()\n self.cfg = cfg\n self.input_size = cfg.input_size\n self.filter_size = cfg.filter_size\n self.kernel_size = cfg.kernel_size\n self.conv_layers = cfg.conv_layers\n self.cross_attn_per_layer = cfg.cross_attn_per_layer\n self.attn_head = cfg.attn_head\n self.drop_out = cfg.drop_out\n\n self.conv = nn.ModuleList()\n self.cattn = nn.ModuleList()\n\n for idx in range(self.conv_layers):\n in_dim = self.input_size if idx == 0 else self.filter_size\n self.conv += [\n nn.Sequential(\n nn.Conv1d(\n in_dim,\n self.filter_size,\n self.kernel_size,\n padding=self.kernel_size // 2,\n ),\n nn.ReLU(),\n nn.LayerNorm(self.filter_size),\n nn.Dropout(self.drop_out),\n )\n ]\n if idx % self.cross_attn_per_layer == 0:\n self.cattn.append(\n torch.nn.Sequential(\n nn.MultiheadAttention(\n self.filter_size,\n self.attn_head,\n batch_first=True,\n kdim=self.filter_size,\n vdim=self.filter_size,\n ),\n nn.LayerNorm(self.filter_size),\n nn.Dropout(0.2),\n )\n )\n\n self.linear = nn.Linear(self.filter_size, 1)\n self.linear.weight.data.normal_(0.0, 0.02)\n\n def forward(self, x, mask, ref_emb, ref_mask):\n \"\"\"\n input:\n x: (B, N, d)\n mask: (B, N), mask is 0\n ref_emb: (B, d, T')\n ref_mask: (B, T'), mask is 0\n\n output:\n dur_pred: (B, N)\n dur_pred_log: (B, N)\n dur_pred_round: (B, N)\n \"\"\"\n\n input_ref_mask = ~(ref_mask.bool()) # (B, T')\n # print(input_ref_mask)\n\n x = x.transpose(1, -1) # (B, N, d) -> (B, d, N)\n\n for idx, (conv, act, ln, dropout) in enumerate(self.conv):\n res = x\n # print(torch.min(x), torch.max(x))\n if idx % self.cross_attn_per_layer == 0:\n attn_idx = idx // self.cross_attn_per_layer\n attn, attn_ln, attn_drop = self.cattn[attn_idx]\n\n attn_res = y_ = x.transpose(1, 2) # (B, d, N) -> (B, N, d)\n\n y_ = attn_ln(y_)\n # print(torch.min(y_), torch.min(y_))\n # print(torch.min(ref_emb), torch.max(ref_emb))\n y_, _ = attn(\n y_,\n ref_emb.transpose(1, 2),\n ref_emb.transpose(1, 2),\n key_padding_mask=input_ref_mask,\n )\n # y_, _ = attn(y_, ref_emb.transpose(1, 2), ref_emb.transpose(1, 2))\n # print(torch.min(y_), torch.min(y_))\n y_ = attn_drop(y_)\n y_ = (y_ + attn_res) / math.sqrt(2.0)\n\n x = y_.transpose(1, 2)\n\n x = conv(x)\n # print(torch.min(x), torch.max(x))\n x = act(x)\n x = ln(x.transpose(1, 2))\n # print(torch.min(x), torch.max(x))\n x = x.transpose(1, 2)\n\n x = dropout(x)\n\n if idx != 0:\n x += res\n\n if mask is not None:\n x = x * mask.to(x.dtype)[:, None, :]\n\n x = self.linear(x.transpose(1, 2))\n x = torch.squeeze(x, -1)\n\n dur_pred = x.exp() - 1\n dur_pred_round = torch.clamp(torch.round(x.exp() - 1), min=0).long()\n\n return {\n \"dur_pred_log\": x,\n \"dur_pred\": dur_pred,\n \"dur_pred_round\": dur_pred_round,\n }" }, { "identifier": "PitchPredictor", "path": "modules/naturalpseech2/transformers.py", "snippet": "class PitchPredictor(nn.Module):\n def __init__(self, cfg):\n super().__init__()\n self.cfg = cfg\n self.input_size = cfg.input_size\n self.filter_size = cfg.filter_size\n self.kernel_size = cfg.kernel_size\n self.conv_layers = cfg.conv_layers\n self.cross_attn_per_layer = cfg.cross_attn_per_layer\n self.attn_head = cfg.attn_head\n self.drop_out = cfg.drop_out\n\n self.conv = nn.ModuleList()\n self.cattn = nn.ModuleList()\n\n for idx in range(self.conv_layers):\n in_dim = self.input_size if idx == 0 else self.filter_size\n self.conv += [\n nn.Sequential(\n nn.Conv1d(\n in_dim,\n self.filter_size,\n self.kernel_size,\n padding=self.kernel_size // 2,\n ),\n nn.ReLU(),\n nn.LayerNorm(self.filter_size),\n nn.Dropout(self.drop_out),\n )\n ]\n if idx % self.cross_attn_per_layer == 0:\n self.cattn.append(\n torch.nn.Sequential(\n nn.MultiheadAttention(\n self.filter_size,\n self.attn_head,\n batch_first=True,\n kdim=self.filter_size,\n vdim=self.filter_size,\n ),\n nn.LayerNorm(self.filter_size),\n nn.Dropout(0.2),\n )\n )\n\n self.linear = nn.Linear(self.filter_size, 1)\n self.linear.weight.data.normal_(0.0, 0.02)\n\n def forward(self, x, mask, ref_emb, ref_mask):\n \"\"\"\n input:\n x: (B, N, d)\n mask: (B, N), mask is 0\n ref_emb: (B, d, T')\n ref_mask: (B, T'), mask is 0\n\n output:\n pitch_pred: (B, T)\n \"\"\"\n\n input_ref_mask = ~(ref_mask.bool()) # (B, T')\n\n x = x.transpose(1, -1) # (B, N, d) -> (B, d, N)\n\n for idx, (conv, act, ln, dropout) in enumerate(self.conv):\n res = x\n if idx % self.cross_attn_per_layer == 0:\n attn_idx = idx // self.cross_attn_per_layer\n attn, attn_ln, attn_drop = self.cattn[attn_idx]\n\n attn_res = y_ = x.transpose(1, 2) # (B, d, N) -> (B, N, d)\n\n y_ = attn_ln(y_)\n y_, _ = attn(\n y_,\n ref_emb.transpose(1, 2),\n ref_emb.transpose(1, 2),\n key_padding_mask=input_ref_mask,\n )\n # y_, _ = attn(y_, ref_emb.transpose(1, 2), ref_emb.transpose(1, 2))\n y_ = attn_drop(y_)\n y_ = (y_ + attn_res) / math.sqrt(2.0)\n\n x = y_.transpose(1, 2)\n\n x = conv(x)\n x = act(x)\n x = ln(x.transpose(1, 2))\n x = x.transpose(1, 2)\n\n x = dropout(x)\n\n if idx != 0:\n x += res\n\n x = self.linear(x.transpose(1, 2))\n x = torch.squeeze(x, -1)\n\n return x" }, { "identifier": "LengthRegulator", "path": "modules/naturalpseech2/transformers.py", "snippet": "class LengthRegulator(nn.Module):\n \"\"\"Length Regulator\"\"\"\n\n def __init__(self):\n super(LengthRegulator, self).__init__()\n\n def LR(self, x, duration, max_len):\n device = x.device\n output = list()\n mel_len = list()\n for batch, expand_target in zip(x, duration):\n expanded = self.expand(batch, expand_target)\n output.append(expanded)\n mel_len.append(expanded.shape[0])\n\n if max_len is not None:\n output = pad(output, max_len)\n else:\n output = pad(output)\n\n return output, torch.LongTensor(mel_len).to(device)\n\n def expand(self, batch, predicted):\n out = list()\n\n for i, vec in enumerate(batch):\n expand_size = predicted[i].item()\n out.append(vec.expand(max(int(expand_size), 0), -1))\n out = torch.cat(out, 0)\n\n return out\n\n def forward(self, x, duration, max_len):\n output, mel_len = self.LR(x, duration, max_len)\n return output, mel_len" } ]

[ { "identifier": "get_current_time_and_date", "path": "kwaiagents/utils/date_utils.py", "snippet": "def get_current_time_and_date(lang=\"en\"):\n solar = Solar.fromDate(datetime.now())\n lunar = solar.getLunar()\n if lang == \"zh\":\n rst = f'''\n当前阳历日期和时间: {str(datetime.now())}\n当前星期: 星期{str(solar.getWeekInChinese())}\n当前农历日期: {str(lunar.toString())}\n当前时辰: {str(lunar.getTimeZhi())}时\n'''.strip()\n else:\n rst = f'''\nCurrent Gregorian date and time: {str(datetime.now())}\nCurrent day of the week: 星期{str(solar.getWeekInChinese())}\nCurrent lunar date: {str(lunar.toString())}\nCurrent Chinese time unit: {str(lunar.getTimeZhi())}时\n'''.strip()\n return rst" }, { "identifier": "transform_to_openai_function", "path": "kwaiagents/utils/function_utils.py", "snippet": "def transform_to_openai_function(func):\n parsed = docstring_parser.parse(func.__doc__)\n\n # Extract descriptions, args, and returns\n description = parsed.short_description\n\n args = {}\n for param in parsed.params:\n args[param.arg_name] = {\n \"type\": param.type_name,\n \"description\": param.description\n }\n\n returns = {\n \"description\": parsed.returns.description if hasattr(parsed.returns, \"returns\") else \"\",\n \"type\": parsed.returns.type_name if hasattr(parsed.returns, \"type_name\") else \"\"\n }\n\n return {\n \"name\": func.name if hasattr(func, \"name\") else func.__name__,\n \"description\": description,\n \"parameters\": {\n \"type\": \"object\",\n \"properties\": args\n },\n \"returns\": returns,\n \"required\": list(args.keys())\n }" } ]

[ { "identifier": "inverse_sigmoid", "path": "utils/general_utils.py", "snippet": "def inverse_sigmoid(x):\n return torch.log(x/(1-x))" }, { "identifier": "get_expon_lr_func", "path": "utils/general_utils.py", "snippet": "def get_expon_lr_func(\n lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000\n):\n \"\"\"\n Copied from Plenoxels\n\n Continuous learning rate decay function. Adapted from JaxNeRF\n The returned rate is lr_init when step=0 and lr_final when step=max_steps, and\n is log-linearly interpolated elsewhere (equivalent to exponential decay).\n If lr_delay_steps>0 then the learning rate will be scaled by some smooth\n function of lr_delay_mult, such that the initial learning rate is\n lr_init*lr_delay_mult at the beginning of optimization but will be eased back\n to the normal learning rate when steps>lr_delay_steps.\n :param conf: config subtree 'lr' or similar\n :param max_steps: int, the number of steps during optimization.\n :return HoF which takes step as input\n \"\"\"\n\n def helper(step):\n if step < 0 or (lr_init == 0.0 and lr_final == 0.0):\n # Disable this parameter\n return 0.0\n if lr_delay_steps > 0:\n # A kind of reverse cosine decay.\n delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(\n 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)\n )\n else:\n delay_rate = 1.0\n t = np.clip(step / max_steps, 0, 1)\n log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t)\n return delay_rate * log_lerp\n\n return helper" }, { "identifier": "build_rotation", "path": "utils/general_utils.py", "snippet": "def build_rotation(r):\n norm = torch.sqrt(r[:,0]*r[:,0] + r[:,1]*r[:,1] + r[:,2]*r[:,2] + r[:,3]*r[:,3])\n\n q = r / norm[:, None]\n\n R = torch.zeros((q.size(0), 3, 3), device='cuda')\n\n r = q[:, 0]\n x = q[:, 1]\n y = q[:, 2]\n z = q[:, 3]\n\n R[:, 0, 0] = 1 - 2 * (y*y + z*z)\n R[:, 0, 1] = 2 * (x*y - r*z)\n R[:, 0, 2] = 2 * (x*z + r*y)\n R[:, 1, 0] = 2 * (x*y + r*z)\n R[:, 1, 1] = 1 - 2 * (x*x + z*z)\n R[:, 1, 2] = 2 * (y*z - r*x)\n R[:, 2, 0] = 2 * (x*z - r*y)\n R[:, 2, 1] = 2 * (y*z + r*x)\n R[:, 2, 2] = 1 - 2 * (x*x + y*y)\n return R" }, { "identifier": "mkdir_p", "path": "utils/system_utils.py", "snippet": "def mkdir_p(folder_path):\n # Creates a directory. equivalent to using mkdir -p on the command line\n try:\n makedirs(folder_path)\n except OSError as exc: # Python >2.5\n if exc.errno == EEXIST and path.isdir(folder_path):\n pass\n else:\n raise" }, { "identifier": "RGB2SH", "path": "utils/sh_utils.py", "snippet": "def RGB2SH(rgb):\n return (rgb - 0.5) / C0" }, { "identifier": "SH2RGB", "path": "utils/sh_utils.py", "snippet": "def SH2RGB(sh):\n return sh * C0 + 0.5" }, { "identifier": "BasicPointCloud", "path": "utils/graphics_utils.py", "snippet": "class BasicPointCloud(NamedTuple):\n points : np.array\n colors : np.array\n normals : np.array" }, { "identifier": "strip_symmetric", "path": "utils/general_utils.py", "snippet": "def strip_symmetric(sym):\n return strip_lowerdiag(sym)" }, { "identifier": "build_scaling_rotation", "path": "utils/general_utils.py", "snippet": "def build_scaling_rotation(s, r):\n L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device=\"cuda\")\n R = build_rotation(r)\n\n L[:,0,0] = s[:,0]\n L[:,1,1] = s[:,1]\n L[:,2,2] = s[:,2]\n\n L = R @ L\n return L" } ]

[ { "identifier": "BaseTool", "path": "agency_swarm/tools/base_tool.py", "snippet": "class BaseTool(OpenAISchema, ABC):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n\n # # Exclude 'run' method from Pydantic model fields\n # self.model_fields.pop(\"run\", None)\n\n @abstractmethod\n def run(self, **kwargs):\n pass" }, { "identifier": "get_b64_screenshot", "path": "agency_swarm/tools/browsing/util/get_b64_screenshot.py", "snippet": "def get_b64_screenshot(wd, element=None):\n # Create a temporary file name but don't open it\n _, tmpfile_name = tempfile.mkstemp(suffix='.png')\n\n try:\n if element:\n element.screenshot(tmpfile_name)\n else:\n wd.get_screenshot_as_file(tmpfile_name)\n\n with open(tmpfile_name, 'rb') as f:\n screenshot = f.read()\n screenshot_b64 = base64.b64encode(screenshot).decode()\n\n return screenshot_b64\n finally:\n # Clean up the temporary file\n os.remove(tmpfile_name)" }, { "identifier": "get_web_driver", "path": "agency_swarm/tools/browsing/util/selenium.py", "snippet": "def get_web_driver():\n try:\n from selenium import webdriver\n from selenium.webdriver.chrome.service import Service as ChromeService\n except ImportError:\n print(\"Selenium not installed. Please install it with pip install selenium\")\n raise ImportError\n\n try:\n from webdriver_manager.chrome import ChromeDriverManager\n except ImportError:\n print(\"webdriver_manager not installed. Please install it with pip install webdriver-manager\")\n raise ImportError\n\n try:\n from selenium_stealth import stealth\n except ImportError:\n print(\"selenium_stealth not installed. Please install it with pip install selenium-stealth\")\n raise ImportError\n\n global wd\n\n if wd:\n return wd\n\n global selenium_config\n chrome_profile_path = selenium_config.get(\"chrome_profile_path\", None)\n profile_directory = None\n user_data_dir = None\n if isinstance(chrome_profile_path, str) and os.path.exists(chrome_profile_path):\n profile_directory = os.path.split(chrome_profile_path)[-1].strip(\"\\\\\").rstrip(\"/\")\n user_data_dir = os.path.split(chrome_profile_path)[0].strip(\"\\\\\").rstrip(\"/\")\n print(f\"Using Chrome profile: {profile_directory}\")\n print(f\"Using Chrome user data dir: {user_data_dir}\")\n print(f\"Using Chrome profile path: {chrome_profile_path}\")\n\n chrome_options = webdriver.ChromeOptions()\n # Removed headless and other options for debugging purposes\n\n chrome_driver_path = ChromeDriverManager().install()\n\n if selenium_config.get(\"headless\", False):\n chrome_options.add_argument('--headless')\n chrome_options.add_argument(\"--window-size=960,1080\")\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-dev-shm-usage')\n chrome_options.add_argument(\"--disable-extensions\")\n chrome_options.add_argument(\"--disable-popup-blocking\")\n chrome_options.add_argument(\"--disable-web-security\")\n chrome_options.add_argument(\"--allow-running-insecure-content\")\n chrome_options.add_argument(\"--disable-gpu\")\n chrome_options.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n chrome_options.add_experimental_option('useAutomationExtension', False)\n if user_data_dir and profile_directory:\n chrome_options.add_argument(f\"user-data-dir={user_data_dir}\")\n chrome_options.add_argument(f\"profile-directory={profile_directory}\")\n\n try:\n wd = webdriver.Chrome(service=ChromeService(chrome_driver_path), options=chrome_options)\n print(\"WebDriver initialized successfully.\")\n # Print the actual profile path being used\n if wd.capabilities['chrome']['userDataDir']:\n print(f\"Profile path in use: {wd.capabilities['chrome']['userDataDir']}\")\n except Exception as e:\n print(f\"Error initializing WebDriver: {e}\")\n raise\n\n stealth(\n wd,\n languages=[\"en-US\", \"en\"],\n vendor=\"Google Inc.\",\n platform=\"Win32\",\n webgl_vendor=\"Intel Inc.\",\n renderer=\"Intel Iris OpenGL Engine\",\n fix_hairline=True,\n )\n\n # wd.set_window_size(960, 1080)\n wd.implicitly_wait(3)\n\n return wd" }, { "identifier": "set_web_driver", "path": "agency_swarm/tools/browsing/util/selenium.py", "snippet": "def set_web_driver(new_wd):\n global wd\n wd = remove_highlight_and_labels(wd)\n wd = new_wd" }, { "identifier": "highlight_elements_with_labels", "path": "agency_swarm/tools/browsing/util/highlights.py", "snippet": "def highlight_elements_with_labels(driver, selector):\n \"\"\"\n This function highlights clickable elements like buttons, links, and certain divs and spans\n that match the given CSS selector on the webpage with a red border and ensures that labels are visible and positioned\n correctly within the viewport.\n\n :param driver: Instance of Selenium WebDriver.\n :param selector: CSS selector for the elements to be highlighted.\n \"\"\"\n script = f\"\"\"\n // Helper function to check if an element is visible\n function isElementVisible(element) {{\n var rect = element.getBoundingClientRect();\n if (rect.width <= 0 || rect.height <= 0 || \n rect.top >= (window.innerHeight || document.documentElement.clientHeight) || \n rect.bottom <= 0 || \n rect.left >= (window.innerWidth || document.documentElement.clientWidth) || \n rect.right <= 0) {{\n return false;\n }}\n // Check if any parent element is hidden, which would hide this element as well\n var parent = element;\n while (parent) {{\n var style = window.getComputedStyle(parent);\n if (style.display === 'none' || style.visibility === 'hidden') {{\n return false;\n }}\n parent = parent.parentElement;\n }}\n return true;\n }}\n\n // Remove previous labels and styles if they exist\n document.querySelectorAll('.highlight-label').forEach(function(label) {{\n label.remove();\n }});\n document.querySelectorAll('.highlighted-element').forEach(function(element) {{\n element.classList.remove('highlighted-element');\n element.removeAttribute('data-highlighted');\n }});\n\n // Inject custom style for highlighting elements\n var styleElement = document.getElementById('highlight-style');\n if (!styleElement) {{\n styleElement = document.createElement('style');\n styleElement.id = 'highlight-style';\n document.head.appendChild(styleElement);\n }}\n styleElement.textContent = `\n .highlighted-element {{ \n border: 2px solid red !important; \n position: relative; \n box-sizing: border-box; \n }}\n .highlight-label {{ \n position: absolute; \n z-index: 2147483647; \n background: yellow; \n color: black; \n font-size: 25px; \n padding: 3px 5px; \n border: 1px solid black; \n border-radius: 3px; \n white-space: nowrap; \n box-shadow: 0px 0px 2px #000; \n top: -25px; \n left: 0; \n display: none;\n }}\n `;\n\n // Function to create and append a label to the body\n function createAndAdjustLabel(element, index) {{\n if (!isElementVisible(element)) return;\n\n element.classList.add('highlighted-element');\n var label = document.createElement('div');\n label.className = 'highlight-label';\n label.textContent = index.toString();\n label.style.display = 'block'; // Make the label visible\n\n // Calculate label position\n var rect = element.getBoundingClientRect();\n var top = rect.top + window.scrollY - 25; // Position label above the element\n var left = rect.left + window.scrollX;\n\n label.style.top = top + 'px';\n label.style.left = left + 'px';\n\n document.body.appendChild(label); // Append the label to the body\n }}\n\n // Select all clickable elements and apply the styles\n var allElements = document.querySelectorAll('{selector}');\n var index = 1;\n allElements.forEach(function(element) {{\n // Check if the element is not already highlighted and is visible\n if (!element.dataset.highlighted && isElementVisible(element)) {{\n element.dataset.highlighted = 'true';\n createAndAdjustLabel(element, index++);\n }}\n }});\n \"\"\"\n\n driver.execute_script(script)\n\n return driver" }, { "identifier": "get_openai_client", "path": "agency_swarm/util/oai.py", "snippet": "def get_openai_client():\n global client\n with client_lock:\n if client is None:\n # Check if the API key is set\n api_key = openai.api_key or os.getenv('OPENAI_API_KEY')\n if api_key is None:\n raise ValueError(\"OpenAI API key is not set. Please set it using set_openai_key.\")\n client = instructor.patch(openai.OpenAI(api_key=api_key,\n max_retries=5))\n return client" } ]

[ { "identifier": "CFM", "path": "resemble_enhance/enhancer/lcfm/cfm.py", "snippet": "class CFM(nn.Module):\n \"\"\"\n This mixin is for general diffusion models.\n\n ψ0 stands for the gaussian noise, and ψ1 is the data point.\n\n Here we follow the CFM style:\n The generation process (reverse process) is from t=0 to t=1.\n The forward process is from t=1 to t=0.\n \"\"\"\n\n cond_dim: int\n output_dim: int\n time_emb_dim: int = 128\n viz_name: str = \"cfm\"\n solver_nfe: int = 32\n solver_method: str = \"midpoint\"\n time_mapping_divisor: int = 4\n\n def __post_init__(self):\n super().__init__()\n self.solver = Solver(\n viz_name=self.viz_name,\n viz_every=1,\n nfe=self.solver_nfe,\n method=self.solver_method,\n time_mapping_divisor=self.time_mapping_divisor,\n )\n self.emb = SinusodialTimeEmbedding(self.time_emb_dim)\n self.net = WN(\n input_dim=self.output_dim,\n output_dim=self.output_dim,\n local_dim=self.cond_dim,\n global_dim=self.time_emb_dim,\n )\n\n def _perturb(self, ψ1: Tensor, t: Tensor | None = None):\n \"\"\"\n Perturb ψ1 to ψt.\n \"\"\"\n raise NotImplementedError\n\n def _sample_ψ0(self, x: Tensor):\n \"\"\"\n Args:\n x: (b c t), which implies the shape of ψ0\n \"\"\"\n shape = list(x.shape)\n shape[1] = self.output_dim\n if self.training:\n g = None\n else:\n g = torch.Generator(device=x.device)\n g.manual_seed(0) # deterministic sampling during eval\n ψ0 = torch.randn(shape, device=x.device, dtype=x.dtype, generator=g)\n return ψ0\n\n @property\n def sigma(self):\n return 1e-4\n\n def _to_ψt(self, *, ψ1: Tensor, ψ0: Tensor, t: Tensor):\n \"\"\"\n Eq (22)\n \"\"\"\n while t.dim() < ψ1.dim():\n t = t.unsqueeze(-1)\n μ = t * ψ1 + (1 - t) * ψ0\n return μ + torch.randn_like(μ) * self.sigma\n\n def _to_u(self, *, ψ1, ψ0: Tensor):\n \"\"\"\n Eq (21)\n \"\"\"\n return ψ1 - ψ0\n\n def _to_v(self, *, ψt, x, t: float | Tensor):\n \"\"\"\n Args:\n ψt: (b c t)\n x: (b c t)\n t: (b)\n Returns:\n v: (b c t)\n \"\"\"\n if isinstance(t, (float, int)):\n t = torch.full(ψt.shape[:1], t).to(ψt)\n t = t.clamp(0, 1) # [0, 1)\n g = self.emb(t) # (b d)\n v = self.net(ψt, l=x, g=g)\n return v\n\n def compute_losses(self, x, y, ψ0) -> dict:\n \"\"\"\n Args:\n x: (b c t)\n y: (b c t)\n Returns:\n losses: dict\n \"\"\"\n t = torch.rand(len(x), device=x.device, dtype=x.dtype)\n t = self.solver.time_mapping(t)\n\n if ψ0 is None:\n ψ0 = self._sample_ψ0(x)\n\n ψt = self._to_ψt(ψ1=y, t=t, ψ0=ψ0)\n\n v = self._to_v(ψt=ψt, t=t, x=x)\n u = self._to_u(ψ1=y, ψ0=ψ0)\n\n losses = dict(l1=F.l1_loss(v, u))\n\n return losses\n\n @torch.inference_mode()\n def sample(self, x, ψ0=None, t0=0.0):\n \"\"\"\n Args:\n x: (b c t)\n Returns:\n y: (b ... t)\n \"\"\"\n if ψ0 is None:\n ψ0 = self._sample_ψ0(x)\n f = lambda t, ψt, dt: self._to_v(ψt=ψt, t=t, x=x)\n ψ1 = self.solver(f=f, ψ0=ψ0, t0=t0)\n return ψ1\n\n def forward(self, x: Tensor, y: Tensor | None = None, ψ0: Tensor | None = None, t0=0.0):\n if y is None:\n y = self.sample(x, ψ0=ψ0, t0=t0)\n else:\n self.losses = self.compute_losses(x, y, ψ0=ψ0)\n return y" }, { "identifier": "IRMAE", "path": "resemble_enhance/enhancer/lcfm/irmae.py", "snippet": "class IRMAE(nn.Module):\n def __init__(\n self,\n input_dim,\n output_dim,\n latent_dim,\n hidden_dim=1024,\n num_irms=4,\n ):\n \"\"\"\n Args:\n input_dim: input dimension\n output_dim: output dimension\n latent_dim: latent dimension\n hidden_dim: hidden layer dimension\n num_irm_matrics: number of implicit rank minimization matrices\n norm: normalization layer\n \"\"\"\n self.input_dim = input_dim\n super().__init__()\n\n self.encoder = nn.Sequential(\n nn.Conv1d(input_dim, hidden_dim, 3, padding=\"same\"),\n *[ResBlock(hidden_dim) for _ in range(4)],\n # Try to obtain compact representation (https://proceedings.neurips.cc/paper/2020/file/a9078e8653368c9c291ae2f8b74012e7-Paper.pdf)\n *[nn.Conv1d(hidden_dim if i == 0 else latent_dim, latent_dim, 1, bias=False) for i in range(num_irms)],\n nn.Tanh(),\n )\n\n self.decoder = nn.Sequential(\n nn.Conv1d(latent_dim, hidden_dim, 3, padding=\"same\"),\n *[ResBlock(hidden_dim) for _ in range(4)],\n nn.Conv1d(hidden_dim, output_dim, 1),\n )\n\n self.head = nn.Sequential(\n nn.Conv1d(output_dim, hidden_dim, 3, padding=\"same\"),\n nn.GELU(),\n nn.Conv1d(hidden_dim, input_dim, 1),\n )\n\n self.estimator = Normalizer()\n\n def encode(self, x):\n \"\"\"\n Args:\n x: (b c t) tensor\n \"\"\"\n z = self.encoder(x) # (b c t)\n _ = self.estimator(z) # Estimate the glboal mean and std of z\n self.stats = {}\n self.stats[\"z_mean\"] = z.mean().item()\n self.stats[\"z_std\"] = z.std().item()\n self.stats[\"z_abs_68\"] = z.abs().quantile(0.6827).item()\n self.stats[\"z_abs_95\"] = z.abs().quantile(0.9545).item()\n self.stats[\"z_abs_99\"] = z.abs().quantile(0.9973).item()\n return z\n\n def decode(self, z):\n \"\"\"\n Args:\n z: (b c t) tensor\n \"\"\"\n return self.decoder(z)\n\n def forward(self, x, skip_decoding=False):\n \"\"\"\n Args:\n x: (b c t) tensor\n skip_decoding: if True, skip the decoding step\n \"\"\"\n z = self.encode(x) # q(z|x)\n\n if skip_decoding:\n # This speeds up the training in cfm only mode\n decoded = None\n else:\n decoded = self.decode(z) # p(x|z)\n predicted = self.head(decoded)\n self.losses = dict(mse=F.mse_loss(predicted, x))\n\n return IRMAEOutput(latent=z, decoded=decoded)" }, { "identifier": "IRMAEOutput", "path": "resemble_enhance/enhancer/lcfm/irmae.py", "snippet": "class IRMAEOutput:\n latent: Tensor # latent vector\n decoded: Tensor | None # decoder output, include extra dim" } ]

[ { "identifier": "CLIPVisionTower", "path": "ChatUniVi/model/multimodal_encoder/clip_encoder.py", "snippet": "class CLIPVisionTower(nn.Module):\n def __init__(self, vision_tower, args=None, delay_load=False):\n super().__init__()\n\n self.is_loaded = False\n\n self.vision_tower_name = vision_tower\n if args is None:\n self.select_layer = -2\n self.select_feature = 'patch'\n else:\n self.select_layer = args.mm_vision_select_layer\n self.select_feature = getattr(args, 'mm_vision_select_feature', 'patch')\n\n if not delay_load:\n self.load_model()\n else:\n self.cfg_only = CLIPVisionConfig.from_pretrained(self.vision_tower_name)\n\n def load_model(self):\n self.image_processor = CLIPImageProcessor.from_pretrained(self.vision_tower_name)\n self.image_eval_processor = CLIPImageProcessor.from_pretrained(self.vision_tower_name)\n self.vision_tower = CLIPVisionModel.from_pretrained(self.vision_tower_name)\n self.vision_tower.requires_grad_(False)\n\n self.is_loaded = True\n\n def feature_select(self, image_forward_outs, select_feature='patch'):\n image_features = image_forward_outs.hidden_states[self.select_layer]\n if select_feature == 'patch':\n image_features = image_features[:, 1:]\n elif select_feature == 'cls_patch':\n image_features = image_features\n else:\n raise ValueError(f'Unexpected select feature: {self.select_feature}')\n return image_features\n\n @torch.no_grad()\n def forward(self, images, select_feature='patch'):\n if type(images) is list:\n image_features = []\n for image in images:\n image_forward_out = self.vision_tower(image.to(device=self.device, dtype=self.dtype).unsqueeze(0), output_hidden_states=True)\n image_feature = self.feature_select(image_forward_out, select_feature).to(image.dtype)\n image_features.append(image_feature)\n else:\n image_forward_outs = self.vision_tower(images.to(device=self.device, dtype=self.dtype), output_hidden_states=True)\n image_features = self.feature_select(image_forward_outs, select_feature).to(images.dtype)\n\n return image_features\n\n @property\n def dummy_feature(self):\n return torch.zeros(1, self.hidden_size, device=self.device, dtype=self.dtype)\n\n @property\n def dtype(self):\n return self.vision_tower.dtype\n\n @property\n def device(self):\n return self.vision_tower.device\n\n @property\n def config(self):\n if self.is_loaded:\n return self.vision_tower.config\n else:\n return self.cfg_only\n\n @property\n def hidden_size(self):\n return self.config.hidden_size\n\n @property\n def num_patches(self):\n return (self.config.image_size // self.config.patch_size) ** 2" }, { "identifier": "CTM", "path": "ChatUniVi/model/cluster.py", "snippet": "class CTM(nn.Module):\n def __init__(self, sample_ratio, embed_dim, dim_out, k=5):\n super().__init__()\n self.sample_ratio = sample_ratio\n self.dim_out = dim_out\n self.k = k\n\n def forward(self, token_dict, sample_ratio=None):\n x = token_dict[\"x\"]\n B, N, C = x.shape\n\n token_weight = x.new_ones(B, N)\n\n if token_dict[\"mask\"] is not None:\n token_weight.masked_fill_((1 - token_dict[\"mask\"]).to(torch.bool), float(\"-inf\"))\n token_weight = token_weight.unsqueeze(2)\n token_dict['x'] = x\n\n if sample_ratio is not None:\n cluster_num = max(math.ceil(N * sample_ratio), 1)\n elif self.sample_ratio > 1:\n cluster_num = max(math.ceil(self.sample_ratio), 1)\n else:\n cluster_num = max(math.ceil(N * self.sample_ratio), 1)\n\n k = min(3, max(cluster_num//2, 1)) if self.k > cluster_num else self.k\n idx_cluster, cluster_num = cluster_dpc_knn(\n token_dict, cluster_num, k, token_mask=token_dict[\"mask\"])\n\n down_dict = merge_tokens(token_dict, idx_cluster, cluster_num, token_weight)\n return down_dict, token_dict" }, { "identifier": "TCBlock", "path": "ChatUniVi/model/cluster.py", "snippet": "class TCBlock(nn.Module):\n def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,\n drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, sr_ratio=1, use_sr_layer=False):\n super().__init__()\n self.apply(self._init_weights)\n\n def _init_weights(self, m):\n if isinstance(m, nn.Linear):\n trunc_normal_(m.weight, std=.02)\n if isinstance(m, nn.Linear) and m.bias is not None:\n nn.init.constant_(m.bias, 0)\n elif isinstance(m, nn.LayerNorm):\n nn.init.constant_(m.bias, 0)\n nn.init.constant_(m.weight, 1.0)\n elif isinstance(m, nn.Conv2d):\n fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels\n fan_out //= m.groups\n m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))\n if m.bias is not None:\n m.bias.data.zero_()\n\n def forward(self, inputs):\n if isinstance(inputs, tuple) or isinstance(inputs, list):\n q_dict, kv_dict = inputs\n else:\n q_dict, kv_dict = inputs, None\n\n x = q_dict['x']\n return q_dict" } ]

[ { "identifier": "Paper", "path": "arxiv_scraper.py", "snippet": "class Paper:\n # paper class should track the list of authors, paper title, abstract, arxiv id\n authors: List[str]\n title: str\n abstract: str\n arxiv_id: str\n\n # add a hash function using arxiv_id\n def __hash__(self):\n return hash(self.arxiv_id)" }, { "identifier": "EnhancedJSONEncoder", "path": "arxiv_scraper.py", "snippet": "class EnhancedJSONEncoder(json.JSONEncoder):\n def default(self, o):\n if dataclasses.is_dataclass(o):\n return dataclasses.asdict(o)\n return super().default(o)" } ]

[ { "identifier": "enums", "path": "src/xllm/enums.py", "snippet": "class General:\nclass Transformers:\nclass Registry:\nclass Datasets:\nclass Collators:\nclass Trainers:\nclass Experiments:\nclass EnvironmentVariables:\nclass LogLevel:" }, { "identifier": "CompletionCollator", "path": "src/xllm/collators/completion.py", "snippet": "class CompletionCollator(BaseCollator):\n \"\"\"\n `CompletionCollator` is a specialized collator class extending `BaseCollator`. It is designed to prepare\n data specifically for text completion tasks, such as language model fine-tuning and sentence completion,\n where a model generates text based on a given prompt.\n\n This class takes care of tokenizing the text input, generating the necessary attention masks, and creating\n targets for the language model, ensuring that the data is presented in a way that is consistent with the\n expectations of the model during training.\n\n This collator is needed for cases when we want to calculate the loss only for the last text in the list.\n For example, these are instances of interacting with an assistant. We don't want to train the model on\n how the user speaks. We don't need the model to be able to imitate the user, so we construct the dataset\n in such a way that at the end of the list of texts (dialogue), there is a phrase by the assistant.\n Essentially, we will be training the model to generate these completions by the assistant.\n\n Key features and methods provided by `CompletionCollator`:\n\n - `__init__`: Initializes a new `CompletionCollator` with a tokenizer, maximum sequence length, and optional\n special markers for the distinction between text prompt and completion.\n\n - `parse_sample`:\n Tokenizes individual text parts, differentiating between the prompt and completion sections,\n and prepares the input and target tokens.\n\n - `parse_batch`: Aggregates multiple samples into a single batch, padding the sequences to the same length and\n generating attention masks.\n\n Attributes:\n - `prefix_end` (`Optional[str]`): A special marker used to identify the end of the prefix or prompt in the text.\n If provided, the tokens following this marker are treated as the completion section for which the model\n generates predictions during training.\n\n - Other attributes inherited from `BaseCollator`, like `tokenizer`, `max_length`, and `separator`.\n\n By providing a structured way to prepare batches of data specifically for completion tasks, the `CompletionCollator`\n facilitates efficient training workflows and ensures the data adheres to the format required for\n effective fine-tuning of language models.\n\n The `CompletionCollator` should be employed when building training loops for models that generate completions\n to given text inputs, as it automates much of the otherwise manual batch preparation processes.\n \"\"\"\n\n def __init__(\n self,\n tokenizer: PreTrainedTokenizer,\n max_length: int,\n prefix_end: Optional[str] = None,\n separator: str = \"\\n\",\n ):\n super().__init__(tokenizer=tokenizer, max_length=max_length, separator=separator)\n\n self.prefix_end = prefix_end\n\n def parse_sample(self, sample: List[str]) -> Tuple[List[int], List[int]]:\n \"\"\"\n Tokenizes a single text sample and prepares individual input and target sequences for text completion tasks.\n\n This method takes a list of text parts, representing the segments of a single raw text sample,\n and processes them to generate sequences of token IDs suitable for model training. It identifies\n a prefix within the text (if specified) and ensures that targets are generated only for the completion section.\n\n Args:\n sample (`List[str]`):\n A list of strings where each element is a part of the text to be tokenized. The last text part\n is considered the completion target when a `prefix_end` is provided.\n\n Returns:\n `Tuple[List[int], List[int]]`: A tuple containing two lists:\n - The first list represents the `input_ids`, token IDs for the model's input sequence.\n - The second list represents the `targets`, corresponding token IDs for labels used during\n loss computation.\n\n The `parse_sample` method performs the following steps for the given text sample:\n\n - Appends a separator to each text part and tokenizes them, generating a list of token indices.\n - Constructs a mask to identify the target tokens within the completion section of the text.\n - Aligns the token indices and the mask to create `input_ids` and `targets`. Padding tokens are used\n for non-target positions in the `targets` list.\n\n The separation between the prefix and completion sections is defined by `self.prefix_end`.\n When this marker is present in the last text part, it distinguishes the section of the text where model\n predictions should align with the provided text (targets for the model).\n\n This method is an integral part of the `CompletionCollator` class, enabling fine-grained control over\n the tokenization and preparation of each text sample prior to batch collation.\n \"\"\"\n\n text_parts = [text + self.separator for text in sample]\n tokenized = self.tokenizer(text_parts)[enums.Transformers.input_ids]\n\n token_indices = list()\n mask = list()\n\n if self.prefix_end and self.prefix_end in text_parts[-1]:\n prefix = text_parts[-1][: text_parts[-1].index(self.prefix_end) + len(self.prefix_end)]\n n_prefix = len(self.tokenizer(prefix)[enums.Transformers.input_ids]) - 1\n else:\n n_prefix = 0\n\n for n_sample, text_indices in enumerate(tokenized):\n if n_sample > 0:\n text_indices = text_indices[1:]\n if n_sample == len(tokenized) - 1:\n sample_mask = [0] * n_prefix + [1] * (len(text_indices) - n_prefix)\n else:\n sample_mask = [0] * len(text_indices)\n\n token_indices.extend(text_indices)\n mask.extend(sample_mask)\n\n input_ids = token_indices[:-1]\n\n targets = list()\n\n for token_index, flag in zip(token_indices[1:], mask[1:]):\n if flag:\n targets.append(token_index)\n else:\n targets.append(self.tokenizer.pad_token_id)\n\n return input_ids, targets\n\n def parse_batch(self, raw_batch: List[RawSample]) -> Batch:\n \"\"\"\n Processes a batch of raw samples and converts them into the format expected by language models\n for completion tasks.\n\n This method is an implementation of the `parse_batch` abstract method from `BaseCollator`.\n It is responsible for tokenizing the text parts within each raw sample, preparing the tokens\n as model inputs (`input_ids`), and generating corresponding targets.\n\n Args:\n raw_batch (`List[RawSample]`):\n A list of dictionaries, each representing a raw text sample. Each sample is expected to contain\n a key-value pair, where the key is specified by `enums.General.text_parts` and the value is a list\n of text parts to be tokenized and processed.\n\n Returns:\n `Batch`: A dictionary that contains three keys (`input_ids`, `attention_mask`, `labels`) with their\n respective tensors, ready for use as input to a language model.\n - `input_ids` and `attention_mask` are used by the model to compute the outputs.\n - `labels` are used to calculate the loss during training.\n\n The `parse_batch` method performs several steps for each raw sample in the batch:\n\n - Splits the sample into text parts and tokenizes them.\n - Determines the prefix length to differentiate between prefix and completion parts according\n to `self.prefix_end`.\n - Constructs the `input_ids` and `labels` by including tokens from the text and assigning padding\n token IDs where necessary.\n - Generates the `attention_mask` to inform the model which tokens to pay attention to during training.\n - Pads the sequences in the batch to match the length of the longest sequence, ensuring batch\n uniformity in size.\n\n This collation logic is essential for text completion tasks, where models typically predict the\n continuation of a given text prompt. By handling the tokenization and the setup of inputs and targets,\n the `CompletionCollator` enables seamless integration with the model's expected input format.\n \"\"\"\n\n input_ids = list()\n targets = list()\n attention_masks = list()\n\n batch_max_length = 0\n\n for sample in raw_batch:\n text_parts = sample[enums.General.text_parts]\n\n if isinstance(text_parts, list):\n sample_input_ids, sample_targets = self.parse_sample(sample=[str(item) for item in text_parts])\n sample_length = len(sample_input_ids)\n\n input_ids.append(sample_input_ids)\n targets.append(sample_targets)\n\n if sample_length > batch_max_length:\n batch_max_length = sample_length\n\n attention_masks.append([1] * sample_length)\n\n for n_sample in range(len(input_ids)):\n pad_sequence = [self.tokenizer.pad_token_id] * (batch_max_length - len(input_ids[n_sample]))\n if pad_sequence:\n additional_attention_mask = [0] * len(pad_sequence)\n if self.tokenizer.padding_side == \"left\":\n input_ids[n_sample] = pad_sequence + input_ids[n_sample]\n targets[n_sample] = pad_sequence + targets[n_sample]\n attention_masks[n_sample] = additional_attention_mask + attention_masks[n_sample]\n else:\n input_ids[n_sample] += pad_sequence\n targets[n_sample] += pad_sequence\n attention_masks[n_sample] += additional_attention_mask\n\n batch = {\n enums.Transformers.input_ids: torch.tensor(input_ids),\n enums.Transformers.attention_mask: torch.tensor(attention_masks),\n enums.Transformers.labels: torch.tensor(targets),\n }\n\n return batch" }, { "identifier": "DATA", "path": "tests/helpers/dummy_data.py", "snippet": "DATA = [\n {\n enums.General.text_parts: [\n \"Person 1: Hello\",\n \"Person 2: It's me\",\n \"Person 1: I was wondering\",\n ]\n },\n {\n enums.General.text_parts: [\n \"You are a sith lord\",\n \"Kenobi: Hello there\",\n \"General Grievous: General Kenobi\",\n ]\n },\n]" } ]

[ { "identifier": "TimestepKeyframeImport", "path": "imports/AdvancedControlNet/control.py", "snippet": "class TimestepKeyframeImport:\n def __init__(self,\n start_percent: float = 0.0,\n strength: float = 1.0,\n interpolation: str = StrengthInterpolationImport.NONE,\n control_weights: ControlWeightsImport = None,\n latent_keyframes: LatentKeyframeGroupImport = None,\n null_latent_kf_strength: float = 0.0,\n inherit_missing: bool = True,\n guarantee_usage: bool = True,\n mask_hint_orig: Tensor = None) -> None:\n self.start_percent = start_percent\n self.start_t = 999999999.9\n self.strength = strength\n self.interpolation = interpolation\n self.control_weights = control_weights\n self.latent_keyframes = latent_keyframes\n self.null_latent_kf_strength = null_latent_kf_strength\n self.inherit_missing = inherit_missing\n self.guarantee_usage = guarantee_usage\n self.mask_hint_orig = mask_hint_orig\n\n def has_control_weights(self):\n return self.control_weights is not None\n \n def has_latent_keyframes(self):\n return self.latent_keyframes is not None\n \n def has_mask_hint(self):\n return self.mask_hint_orig is not None\n \n \n @classmethod\n def default(cls) -> 'TimestepKeyframeImport':\n return cls(0.0)" }, { "identifier": "TimestepKeyframeGroupImport", "path": "imports/AdvancedControlNet/control.py", "snippet": "class TimestepKeyframeGroupImport:\n def __init__(self) -> None:\n self.keyframes: list[TimestepKeyframeImport] = []\n self.keyframes.append(TimestepKeyframeImport.default())\n\n def add(self, keyframe: TimestepKeyframeImport) -> None:\n added = False\n # replace existing keyframe if same start_percent\n for i in range(len(self.keyframes)):\n if self.keyframes[i].start_percent == keyframe.start_percent:\n self.keyframes[i] = keyframe\n added = True\n break\n if not added:\n self.keyframes.append(keyframe)\n self.keyframes.sort(key=lambda k: k.start_percent)\n\n def get_index(self, index: int) -> Union[TimestepKeyframeImport, None]:\n try:\n return self.keyframes[index]\n except IndexError:\n return None\n \n def has_index(self, index: int) -> int:\n return index >=0 and index < len(self.keyframes)\n\n def __getitem__(self, index) -> TimestepKeyframeImport:\n return self.keyframes[index]\n \n def __len__(self) -> int:\n return len(self.keyframes)\n\n def is_empty(self) -> bool:\n return len(self.keyframes) == 0\n \n def clone(self) -> 'TimestepKeyframeGroupImport':\n cloned = TimestepKeyframeGroupImport()\n for tk in self.keyframes:\n cloned.add(tk)\n return cloned\n \n @classmethod\n def default(cls, keyframe: TimestepKeyframeImport) -> 'TimestepKeyframeGroupImport':\n group = cls()\n group.keyframes[0] = keyframe\n return group" }, { "identifier": "ControlWeightsImport", "path": "imports/AdvancedControlNet/control.py", "snippet": "class ControlWeightsImport:\n def __init__(self, weight_type: str, base_multiplier: float=1.0, flip_weights: bool=False, weights: list[float]=None, weight_mask: Tensor=None):\n self.weight_type = weight_type\n self.base_multiplier = base_multiplier\n self.flip_weights = flip_weights\n self.weights = weights\n if self.weights is not None and self.flip_weights:\n self.weights.reverse()\n self.weight_mask = weight_mask\n\n def get(self, idx: int) -> Union[float, Tensor]:\n # if weights is not none, return index\n if self.weights is not None:\n return self.weights[idx]\n return 1.0\n\n @classmethod\n def default(cls):\n return cls(ControlWeightTypeImport.DEFAULT)\n\n @classmethod\n def universal(cls, base_multiplier: float, flip_weights: bool=False):\n return cls(ControlWeightTypeImport.UNIVERSAL, base_multiplier=base_multiplier, flip_weights=flip_weights)\n \n @classmethod\n def universal_mask(cls, weight_mask: Tensor):\n return cls(ControlWeightTypeImport.UNIVERSAL, weight_mask=weight_mask)\n\n @classmethod\n def t2iadapter(cls, weights: list[float]=None, flip_weights: bool=False):\n if weights is None:\n weights = [1.0]*12\n return cls(ControlWeightTypeImport.T2IADAPTER, weights=weights,flip_weights=flip_weights)\n\n @classmethod\n def controlnet(cls, weights: list[float]=None, flip_weights: bool=False):\n if weights is None:\n weights = [1.0]*13\n return cls(ControlWeightTypeImport.CONTROLNET, weights=weights, flip_weights=flip_weights)\n \n @classmethod\n def controllora(cls, weights: list[float]=None, flip_weights: bool=False):\n if weights is None:\n weights = [1.0]*10\n return cls(ControlWeightTypeImport.CONTROLLORA, weights=weights, flip_weights=flip_weights)\n \n @classmethod\n def controllllite(cls, weights: list[float]=None, flip_weights: bool=False):\n if weights is None:\n # TODO: make this have a real value\n weights = [1.0]*200\n return cls(ControlWeightTypeImport.CONTROLLLLITE, weights=weights, flip_weights=flip_weights)" }, { "identifier": "get_properly_arranged_t2i_weights", "path": "imports/AdvancedControlNet/control.py", "snippet": "def get_properly_arranged_t2i_weights(initial_weights: list[float]):\n new_weights = []\n new_weights.extend([initial_weights[0]]*3)\n new_weights.extend([initial_weights[1]]*3)\n new_weights.extend([initial_weights[2]]*3)\n new_weights.extend([initial_weights[3]]*3)\n return new_weights" }, { "identifier": "linear_conversion", "path": "imports/AdvancedControlNet/control.py", "snippet": "def linear_conversion(x, x_min=0.0, x_max=1.0, new_min=0.0, new_max=1.0):\n return (((x - x_min)/(x_max - x_min)) * (new_max - new_min)) + new_min" }, { "identifier": "logger", "path": "imports/AdvancedControlNet/logger.py", "snippet": "class ColoredFormatter(logging.Formatter):\n COLORS = {\n \"DEBUG\": \"\\033[0;36m\", # CYAN\n \"INFO\": \"\\033[0;32m\", # GREEN\n \"WARNING\": \"\\033[0;33m\", # YELLOW\n \"ERROR\": \"\\033[0;31m\", # RED\n \"CRITICAL\": \"\\033[0;37;41m\", # WHITE ON RED\n \"RESET\": \"\\033[0m\", # RESET COLOR\n }\n def format(self, record):" } ]

[ { "identifier": "ConvertAnsiEscape", "path": "gifos/utils/convert_ansi_escape.py", "snippet": "class ConvertAnsiEscape:\n \"\"\"A class for converting ANSI escape codes to color values.\"\"\"\n\n __color_scheme = gifos_settings.get(\"general\", {}).get(\"color_scheme\")\n\n @staticmethod\n def __get_color(color_dict, color_name, def_color):\n \"\"\"Get the color value from the color dictionary.\n\n This method takes a color dictionary, a color name, and a default color as\n input. If the color dictionary is indeed a dictionary and contains the color\n name, it returns the corresponding color value. Otherwise, it returns the\n default color.\n\n :param color_dict: The color dictionary to get the color value from.\n :type color_dict: dict\n :param color_name: The name of the color to get.\n :type color_name: str\n :param def_color: The default color to return if the color name is not in the\n color dictionary.\n :type def_color: str\n :return: The color value corresponding to the color name if it's in the color\n dictionary, otherwise the default color.\n :rtype: str\n \"\"\"\n return (\n color_dict.get(color_name, def_color)\n if isinstance(color_dict, dict)\n else def_color\n )\n\n # fmt: off\n ANSI_ESCAPE_MAP_TXT_COLOR = {\n # normal color mode\n \"30\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"black\", \"#232526\"),\n \"31\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"red\", \"#df5b61\"),\n \"32\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"green\", \"#78b892\"),\n \"33\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"yellow\", \"#de8f78\"),\n \"34\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"blue\", \"#6791c9\"),\n \"35\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"magenta\", \"#bc83e3\"),\n \"36\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"cyan\", \"#67afc1\"),\n \"37\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"white\", \"#e4e6e7\"),\n \"39\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"default_colors\"), \"fg\", \"#edeff0\"),\n # bright color mode\n \"90\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"black\", \"#2c2e2f\"),\n \"91\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"red\", \"#e8646a\"),\n \"92\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"green\", \"#81c19b\"),\n \"93\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"yellow\", \"#e79881\"),\n \"94\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"blue\", \"#709ad2\"),\n \"95\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"magenta\", \"#c58cec\"),\n \"96\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"cyan\", \"#70b8ca\"),\n \"97\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"white\", \"#f2f4f5\"),\n } \n\n ANSI_ESCAPE_MAP_BG_COLOR = {\n # normal color mode\n \"40\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"black\", \"#232526\"),\n \"41\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"red\", \"#df5b61\"),\n \"42\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"green\", \"#78b892\"),\n \"43\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"yellow\", \"#de8f78\"),\n \"44\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"blue\", \"#6791c9\"),\n \"45\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"magenta\", \"#bc83e3\"),\n \"46\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"cyan\", \"#67afc1\"),\n \"47\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"normal_colors\"), \"white\", \"#e4e6e7\"),\n \"49\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"default_colors\"), \"bg\", \"#0c0e0f\"),\n # bright color mode\n \"100\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"black\", \"#2c2e2f\"),\n \"101\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"red\", \"#e8646a\"),\n \"102\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"green\", \"#81c19b\"),\n \"103\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"yellow\", \"#e79881\"),\n \"104\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"blue\", \"#709ad2\"),\n \"105\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"magenta\", \"#c58cec\"),\n \"106\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"cyan\", \"#70b8ca\"),\n \"107\": __get_color(ansi_escape_colors.get(__color_scheme, {}).get(\"bright_colors\"), \"white\", \"#f2f4f5\"),\n }\n # fmt: on\n\n @classmethod\n def convert(cls, escape_code) -> AnsiEscape:\n \"\"\"Convert an ANSI escape code to a color value.\n\n This method takes an ANSI escape code as input and returns an `AnsiEscape`\n object containing the corresponding color value and operation (text color or\n background color). The method uses two dictionaries `ANSI_ESCAPE_MAP_TXT_COLOR`\n and `ANSI_ESCAPE_MAP_BG_COLOR` to map ANSI escape codes to color values for text\n and background colors respectively.\n\n :param escape_code: The ANSI escape code to convert.\n :type escape_code: str\n :return: An `AnsiEscape` object containing the color value and operation if the\n escape code is found in the dictionaries, otherwise None.\n :rtype: AnsiEscape or None\n \"\"\"\n txt_color = cls.ANSI_ESCAPE_MAP_TXT_COLOR.get(escape_code)\n if txt_color:\n return AnsiEscape(data=txt_color, oper=\"txt_color\")\n\n bg_color = cls.ANSI_ESCAPE_MAP_BG_COLOR.get(escape_code)\n if bg_color:\n return AnsiEscape(data=bg_color, oper=\"bg_color\")\n\n return None" }, { "identifier": "gifos_settings", "path": "gifos/utils/load_config.py", "snippet": "def load_toml(file_name: str) -> dict:\n def __update_config_with_env_vars(config, prefix=\"GIFOS\"):" } ]

[ { "identifier": "cfg", "path": "src/kanban_python/config.py", "snippet": "class KanbanConfig:\n def __init__(self, path=CONFIG_FILE_PATH) -> None:\n def __repr__(self) -> str:\n def save(self):\n def config(self) -> configparser.ConfigParser:\n def active_board(self) -> str:\n def active_board(self, new_board):\n def kanban_boards(self) -> list:\n def kanban_boards_dict(self) -> dict:\n def kanban_boards_dict(self, board_name: str) -> dict:\n def active_board_path(self) -> str:\n def show_footer(self):\n def show_footer(self, visible):\n def col_min_width(self) -> int:\n def col_min_width(self, new_width: int) -> None:\n def kanban_columns_dict(self) -> dict:\n def kanban_columns_dict(self, updated_dict) -> dict:\n def vis_cols(self) -> list:\n def done_limit(self) -> int:\n def done_limit(self, new_limit: int) -> None:\n def scanned_files(self) -> list:\n def scanned_files(self, new_files_to_scan: str) -> None:\n def scanned_patterns(self) -> list:\n def scanned_patterns(self, new_patterns_to_scan: str) -> None:\ndef create_init_config(conf_path=CONFIG_PATH, data_path=DATA_PATH):\ndef delete_current_folder_board_from_config(\n cfg=cfg, curr_path: str = str(Path.cwd())\n) -> None:\ndef check_if_board_name_exists_in_config(boardname: str, cfg=cfg) -> bool:\ndef check_if_current_active_board_in_board_list(cfg=cfg) -> bool:\ndef delete_board_from_config(board_name, cfg=cfg) -> None:\ndef check_config_exists(path=CONFIG_FILE_PATH) -> bool:\ndef get_json_path(boardname: str):" }, { "identifier": "BOARD_CAPTION_STRING", "path": "src/kanban_python/constants.py", "snippet": "BOARD_CAPTION_STRING = \"Tasks have the following Structure:\\\n [[cyan]ID[/]] ([orange3]TAG[/]) [white]Task Title[/] |[red]Days Left[/]|\"" }, { "identifier": "COLOR_DICT", "path": "src/kanban_python/constants.py", "snippet": "COLOR_DICT = {\n \"Ready\": \"[red]Ready[/]\",\n \"Doing\": \"[yellow]Doing[/]\",\n \"Done\": \"[green]Done[/]\",\n \"Deleted\": \"[deep_pink4]Deleted[/]\",\n \"Archived\": \"[dark_goldenrod]Archived[/]\",\n}" }, { "identifier": "CONFIG_FILE_PATH", "path": "src/kanban_python/constants.py", "snippet": "CONFIG_FILE_PATH = CONFIG_PATH / CONFIG_FILE_NAME" }, { "identifier": "FOOTER", "path": "src/kanban_python/constants.py", "snippet": "FOOTER = [FOOTER_FIRST, FOOTER_LAST]" }, { "identifier": "REPORT_COLORS", "path": "src/kanban_python/constants.py", "snippet": "REPORT_COLORS = [\"#161b22\", \"#0e4429\", \"#006d32\", \"#26a641\", \"#39d353\"]" }, { "identifier": "calculate_days_left_till_due", "path": "src/kanban_python/utils.py", "snippet": "def get_motivational_quote() -> str:\ndef current_time_to_str() -> str:\ndef calculate_time_delta_str(start_time_str: str, end_time_str: str) -> float:\ndef create_status_dict_for_rows(data: dict, vis_cols: list) -> dict:\ndef check_if_done_col_leq_X(cfg, data: dict) -> bool:\ndef check_if_there_are_visible_tasks_in_board(data: dict, vis_cols: list) -> bool:\ndef move_first_done_task_to_archive(data: dict):\ndef delete_json_file(db_path: str) -> None:\ndef check_board_name_valid(boardname: str):\ndef scan_files(path=Path.cwd(), endings: list = [\".py\"]):\n def recursive_search(path, file_list: list, progress):\ndef scan_for_todos(\n file_paths: list, rel_path=Path.cwd(), patterns: list = [\"#TODO\", \"# TODO\"]\n) -> list:\ndef split_todo_in_tag_and_title(todo: str, patterns: list):\ndef get_tag_id_choices(data_dict: dict, vis_cols: list) -> list:\ndef check_scanner_files_valid(files: str) -> bool:\ndef check_scanner_patterns_valid(patterns: str) -> bool:\ndef get_iso_calender_info(date_str: str):\ndef create_dict_for_report_view(completed_tasks: list):\ndef create_color_mapping(amount_list: list, max_val: int):\ndef create_report_document(boards_dict: dict):\ndef check_due_date_format(date_str: str) -> bool:\ndef due_date_datetime_to_date(date_datetime: str) -> str:\ndef due_date_date_to_datetime(date_str: str) -> str:\ndef calculate_days_left_till_due(due_date: str):" } ]

[ { "identifier": "exists", "path": "audioldm/utils.py", "snippet": "def exists(x):\n return x is not None" }, { "identifier": "default", "path": "audioldm/utils.py", "snippet": "def default(val, d):\n if exists(val):\n return val\n return d() if isfunction(d) else d" }, { "identifier": "count_params", "path": "audioldm/utils.py", "snippet": "def count_params(model, verbose=False):\n total_params = sum(p.numel() for p in model.parameters())\n if verbose:\n print(f\"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.\")\n return total_params" }, { "identifier": "instantiate_from_config", "path": "audioldm/utils.py", "snippet": "def instantiate_from_config(config):\n if not \"target\" in config:\n if config == \"__is_first_stage__\":\n return None\n elif config == \"__is_unconditional__\":\n return None\n raise KeyError(\"Expected key `target` to instantiate.\")\n return get_obj_from_str(config[\"target\"])(**config.get(\"params\", dict()))" }, { "identifier": "LitEma", "path": "audioldm/latent_diffusion/ema.py", "snippet": "class LitEma(nn.Module):\n def __init__(self, model, decay=0.9999, use_num_upates=True):\n super().__init__()\n if decay < 0.0 or decay > 1.0:\n raise ValueError(\"Decay must be between 0 and 1\")\n\n self.m_name2s_name = {}\n self.register_buffer(\"decay\", torch.tensor(decay, dtype=torch.float32))\n self.register_buffer(\n \"num_updates\",\n torch.tensor(0, dtype=torch.int)\n if use_num_upates\n else torch.tensor(-1, dtype=torch.int),\n )\n\n for name, p in model.named_parameters():\n if p.requires_grad:\n # remove as '.'-character is not allowed in buffers\n s_name = name.replace(\".\", \"\")\n self.m_name2s_name.update({name: s_name})\n self.register_buffer(s_name, p.clone().detach().data)\n\n self.collected_params = []\n\n def forward(self, model):\n decay = self.decay\n\n if self.num_updates >= 0:\n self.num_updates += 1\n decay = min(self.decay, (1 + self.num_updates) / (10 + self.num_updates))\n\n one_minus_decay = 1.0 - decay\n\n with torch.no_grad():\n m_param = dict(model.named_parameters())\n shadow_params = dict(self.named_buffers())\n\n for key in m_param:\n if m_param[key].requires_grad:\n sname = self.m_name2s_name[key]\n shadow_params[sname] = shadow_params[sname].type_as(m_param[key])\n shadow_params[sname].sub_(\n one_minus_decay * (shadow_params[sname] - m_param[key])\n )\n else:\n assert not key in self.m_name2s_name\n\n def copy_to(self, model):\n m_param = dict(model.named_parameters())\n shadow_params = dict(self.named_buffers())\n for key in m_param:\n if m_param[key].requires_grad:\n m_param[key].data.copy_(shadow_params[self.m_name2s_name[key]].data)\n else:\n assert not key in self.m_name2s_name\n\n def store(self, parameters):\n \"\"\"\n Save the current parameters for restoring later.\n Args:\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\n temporarily stored.\n \"\"\"\n self.collected_params = [param.clone() for param in parameters]\n\n def restore(self, parameters):\n \"\"\"\n Restore the parameters stored with the `store` method.\n Useful to validate the model with EMA parameters without affecting the\n original optimization process. Store the parameters before the\n `copy_to` method. After validation (or model saving), use this to\n restore the former parameters.\n Args:\n parameters: Iterable of `torch.nn.Parameter`; the parameters to be\n updated with the stored parameters.\n \"\"\"\n for c_param, param in zip(self.collected_params, parameters):\n param.data.copy_(c_param.data)" }, { "identifier": "make_beta_schedule", "path": "audioldm/latent_diffusion/util.py", "snippet": "def make_beta_schedule(\n schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3\n):\n if schedule == \"linear\":\n betas = (\n torch.linspace(\n linear_start**0.5, linear_end**0.5, n_timestep, dtype=torch.float64\n )\n ** 2\n )\n\n elif schedule == \"cosine\":\n timesteps = (\n torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s\n )\n alphas = timesteps / (1 + cosine_s) * np.pi / 2\n alphas = torch.cos(alphas).pow(2)\n alphas = alphas / alphas[0]\n betas = 1 - alphas[1:] / alphas[:-1]\n betas = np.clip(betas, a_min=0, a_max=0.999)\n\n elif schedule == \"sqrt_linear\":\n betas = torch.linspace(\n linear_start, linear_end, n_timestep, dtype=torch.float64\n )\n elif schedule == \"sqrt\":\n betas = (\n torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64)\n ** 0.5\n )\n else:\n raise ValueError(f\"schedule '{schedule}' unknown.\")\n return betas.numpy()" }, { "identifier": "extract_into_tensor", "path": "audioldm/latent_diffusion/util.py", "snippet": "def extract_into_tensor(a, t, x_shape):\n b, *_ = t.shape\n out = a.gather(-1, t).contiguous()\n return out.reshape(b, *((1,) * (len(x_shape) - 1))).contiguous()" }, { "identifier": "noise_like", "path": "audioldm/latent_diffusion/util.py", "snippet": "def noise_like(shape, device, repeat=False):\n repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(\n shape[0], *((1,) * (len(shape) - 1))\n )\n noise = lambda: torch.randn(shape, device=device)\n return repeat_noise() if repeat else noise()" } ]

[ { "identifier": "config", "path": "common/config.py", "snippet": "def get_data_connection():\ndef get_cache_connection():\ndef handle_default_config():\ndef load_data():\ndef save_data(config_data):\ndef getCache(module, key):\ndef updateCache(module, key, data):\ndef resetRequestTime(ip):\ndef updateRequestTime(ip):\ndef getRequestTime(ip):\ndef read_data(key):\ndef write_data(key, value):\ndef push_to_list(key, obj):\ndef write_config(key, value):\ndef read_default_config(key):\ndef _read_config(key):\ndef read_config(key):\ndef write_data(key, value):\ndef initConfig():\ndef ban_ip(ip_addr, ban_time=-1):\ndef check_ip_banned(ip_addr):\nclass ConfigReadException(Exception):\nclass ConfigReadException(Exception):" }, { "identifier": "lxsecurity", "path": "common/lxsecurity.py", "snippet": "def checklxmheader(lxm, url):" }, { "identifier": "log", "path": "common/log.py", "snippet": "def log(self, message, allow_hidden=True):\n if self.module_name == \"flask\" and \"\\n\" in message:\n if message.startswith(\"Error\"):\n return self._logger.error(message)\n for m in message.split(\"\\n\"):\n if \"WARNING\" in m:\n self._logger.warning(m)\n else:\n self._logger.info(m)\n return\n if len(str(message)) > log_length_limit and allow_hidden:\n message = str(message)[:log_length_limit] + \" ...\"\n self._logger.info(message)" }, { "identifier": "Httpx", "path": "common/Httpx.py", "snippet": "def is_valid_utf8(text):\ndef is_plain_text(text):\ndef convert_dict_to_form_string(dic):\ndef log_plaintext(text):\ndef request(url, options = {}):\n def _json():\ndef checkcn():\n def __init__(self, status, content, headers):\n def json(self):\nasync def convert_to_requests_response(aiohttp_response):\nasync def AsyncRequest(url, options = {}):\nclass ClientResponse:" }, { "identifier": "variable", "path": "common/variable.py", "snippet": "def _read_config_file():\ndef _read_config(key):" }, { "identifier": "scheduler", "path": "common/scheduler.py", "snippet": "class taskWrapper:\n def __init__(self, name, function, interval = 86400, args = {}, latest_execute = 0):\n def check_available(self):\n async def run(self):\ndef append(name, task, interval = 86400, args = {}):\nasync def thread_runner():\nasync def run():" }, { "identifier": "lx_script", "path": "common/lx_script.py", "snippet": "async def get_response(retry = 0):\nasync def get_script():\nasync def generate_script_response(request):" } ]

[ { "identifier": "Identity", "path": "kandinsky3/model/nn.py", "snippet": "class Identity(nn.Module):\n def __init__(self, *args, **kwargs):\n super().__init__()\n\n @staticmethod\n def forward(x, *args, **kwargs):\n return x" }, { "identifier": "Attention", "path": "kandinsky3/model/nn.py", "snippet": "class Attention(nn.Module):\n\n def __init__(self, in_channels, out_channels, context_dim, head_dim=64):\n super().__init__()\n assert out_channels % head_dim == 0\n self.num_heads = out_channels // head_dim\n self.scale = head_dim ** -0.5\n\n self.to_query = nn.Linear(in_channels, out_channels, bias=False)\n self.to_key = nn.Linear(context_dim, out_channels, bias=False)\n self.to_value = nn.Linear(context_dim, out_channels, bias=False)\n\n self.output_layer = nn.Linear(out_channels, out_channels, bias=False)\n\n def forward(self, x, context, context_mask=None):\n query = rearrange(self.to_query(x), 'b n (h d) -> b h n d', h=self.num_heads)\n key = rearrange(self.to_key(context), 'b n (h d) -> b h n d', h=self.num_heads)\n value = rearrange(self.to_value(context), 'b n (h d) -> b h n d', h=self.num_heads)\n\n attention_matrix = einsum('b h i d, b h j d -> b h i j', query, key) * self.scale\n if exist(context_mask):\n max_neg_value = -torch.finfo(attention_matrix.dtype).max\n context_mask = rearrange(context_mask, 'b j -> b 1 1 j')\n attention_matrix = attention_matrix.masked_fill(~context_mask, max_neg_value)\n attention_matrix = attention_matrix.softmax(dim=-1)\n\n out = einsum('b h i j, b h j d -> b h i d', attention_matrix, value)\n out = rearrange(out, 'b h n d -> b n (h d)')\n out = self.output_layer(out)\n return out" }, { "identifier": "SinusoidalPosEmb", "path": "kandinsky3/model/nn.py", "snippet": "class SinusoidalPosEmb(nn.Module):\n\n def __init__(self, dim):\n super().__init__()\n self.dim = dim\n\n def forward(self, x):\n half_dim = self.dim // 2\n emb = math.log(10000) / (half_dim - 1)\n emb = torch.exp(torch.arange(half_dim, device=x.device) * -emb)\n emb = rearrange(x, 'i -> i 1') * rearrange(emb, 'j -> 1 j')\n return torch.cat((emb.sin(), emb.cos()), dim=-1)" }, { "identifier": "ConditionalGroupNorm", "path": "kandinsky3/model/nn.py", "snippet": "class ConditionalGroupNorm(nn.Module):\n\n def __init__(self, groups, normalized_shape, context_dim):\n super().__init__()\n self.norm = nn.GroupNorm(groups, normalized_shape, affine=False)\n self.context_mlp = nn.Sequential(\n nn.SiLU(),\n nn.Linear(context_dim, 2 * normalized_shape)\n )\n self.context_mlp[1].weight.data.zero_()\n self.context_mlp[1].bias.data.zero_()\n\n def forward(self, x, context):\n context = self.context_mlp(context)\n ndims = ' 1' * len(x.shape[2:])\n context = rearrange(context, f'b c -> b c{ndims}')\n\n scale, shift = context.chunk(2, dim=1)\n x = self.norm(x) * (scale + 1.) + shift\n return x" }, { "identifier": "exist", "path": "kandinsky3/model/utils.py", "snippet": "def exist(item):\n return item is not None" }, { "identifier": "set_default_item", "path": "kandinsky3/model/utils.py", "snippet": "def set_default_item(condition, item_1, item_2=None):\n if condition:\n return item_1\n else:\n return item_2" }, { "identifier": "set_default_layer", "path": "kandinsky3/model/utils.py", "snippet": "def set_default_layer(condition, layer_1, args_1=[], kwargs_1={}, layer_2=Identity, args_2=[], kwargs_2={}):\n if condition:\n return layer_1(*args_1, **kwargs_1)\n else:\n return layer_2(*args_2, **kwargs_2)" } ]

[ { "identifier": "utils", "path": "torchexplorer/utils.py", "snippet": "def iter_not_none(iterable: Iterable[Any]) -> Iterator[Any]:\ndef enum_not_none(iterable: Iterable[Any]) -> Iterator[tuple[int, Any]]:\ndef interleave(l1: list[Any], l2: list[Any]) -> list[Any]:\ndef list_add(l1: list[float], l2: list[float]) -> list[float]:" }, { "identifier": "core", "path": "torchexplorer/core.py", "snippet": "class SizeTracker:\nclass ModuleInvocationHistograms:\nclass ModuleSharedHistograms:\nclass ExplorerMetadata:\nclass ModuleInvocationStructure():\nclass DummyAttachModule(nn.Module):\n def __init__(\n self,\n module: nn.Module,\n invocation_id: InvocationId,\n structure_id: int,\n input_n: int,\n output_n: int\n ):\n def module_metadata(self) -> ExplorerMetadata:\n def get_inner_structure(\n self, module: nn.Module, invocation_id: int\n ) -> Optional['ModuleInvocationStructure']:\n def get_inner_structure_from_memory_id(\n self, memory_id: int\n ) -> Optional['ModuleInvocationStructure']:\n def get_inner_structure_from_id(\n self, structure_id: int\n ) -> Optional['ModuleInvocationStructure']:\n def _inner_filter(self, test_fn: Callable) -> Optional['ModuleInvocationStructure']:\n def str_impl(self) -> str:\n def __init__(self):\n def forward(self, x):" }, { "identifier": "Tooltip", "path": "torchexplorer/components/tooltip.py", "snippet": "class Tooltip:\n \"\"\"The tooltip that pops up next to a Module.\"\"\"\n\n def __init__(self, title: str, keys: list[str], vals: list[str]):\n self.title = title\n self.keys = keys\n self.vals = vals\n \n @classmethod\n def create_io(cls, tracker: SizeTracker) -> 'Tooltip':\n name = tracker.type.split('.')[-1]\n keys, vals = ['size'], [str(tracker.size).replace('None', dash)]\n return Tooltip(name, keys, vals)\n \n @classmethod\n def create_moduleinvocation(\n cls, module: Module, parent_module: Module, invocation_id: InvocationId\n ) -> 'Tooltip':\n\n name_in_parent = cls._get_name_in_parent(module, parent_module)\n\n io_shape_keys, io_shape_vals = cls._get_io_shape_keyvals(module, invocation_id)\n extra_repr_keys, extra_repr_vals = cls._get_extra_repr_keyvals(module)\n\n keys = io_shape_keys + extra_repr_keys\n vals = io_shape_vals + extra_repr_vals\n\n assert len(keys) == len(vals)\n\n return Tooltip(name_in_parent, keys, vals)\n \n @classmethod\n def create_attach(cls, module: Module) -> 'Tooltip':\n return cls.create_io(module.torchexplorer_metadata.input_sizes[0][0])\n \n @classmethod\n def _get_name_in_parent(cls, module: Module, parent_module: Module) -> str:\n name_in_parent = ''\n for name, m in parent_module.named_children():\n if m == module:\n name_in_parent = name\n break\n \n if isinstance(m, ModuleList):\n for i, mm in enumerate(m):\n if mm == module:\n name_in_parent = f'{name}[{i}]'\n break\n \n if isinstance(m, ModuleDict):\n for k, mm in m.items():\n if mm == module:\n name_in_parent = f'{name}[{k}]'\n break\n \n return name_in_parent\n\n @classmethod\n def _get_io_shape_keyvals(\n cls, module: Module, invocation_id: InvocationId\n ) -> tuple[list[str], list[str]]:\n\n metadata = module.torchexplorer_metadata \n\n keys, vals = [], []\n\n one_input = len(metadata.input_sizes[invocation_id]) == 1\n for i, input_tracker in enumerate(metadata.input_sizes[invocation_id]):\n keys.append('in_size' if one_input else f'in{i}_size')\n vals.append(str(input_tracker.size).replace('None', dash))\n \n one_output = len(metadata.output_sizes[invocation_id]) == 1\n for i, output_tracker in enumerate(metadata.output_sizes[invocation_id]):\n keys.append('out_size' if one_output else f'out{i}_size')\n vals.append(str(output_tracker.size).replace('None', dash))\n\n return keys, vals\n \n @classmethod\n def _get_extra_repr_keyvals(cls, module: Module) -> tuple[list[str], list[str]]:\n try:\n keys, vals = [], []\n extra_rep = module.extra_repr()\n pairs = re.split(r',\\s*(?![^()]*\\))(?![^[]]*\\])', extra_rep)\n for pair in pairs:\n if pair == '':\n continue\n k, v = pair.split('=') if ('=' in pair) else (dash, pair)\n keys.append(k.strip())\n vals.append(v.strip())\n except Exception:\n keys, vals = [], []\n \n return keys, vals" }, { "identifier": "ModuleInvocationHistograms", "path": "torchexplorer/core.py", "snippet": "class ModuleInvocationHistograms:\n \"\"\"The histograms associated to a particular InvocationId on a module.\"\"\"\n input_hists: list[IncrementalHistogram] = field(default_factory=lambda: [])\n output_hists: list[IncrementalHistogram] = field(default_factory=lambda: [])" }, { "identifier": "ModuleInvocationStructure", "path": "torchexplorer/core.py", "snippet": "class ModuleInvocationStructure():\n \"\"\"The parsed structure of a module invocation.\n\n There can be multiple of these for a particular module if that module's forward\n method is invoked multiple times on the forwards pass of a parent.\"\"\"\n\n def __init__(\n self,\n module: nn.Module,\n invocation_id: InvocationId,\n structure_id: int,\n input_n: int,\n output_n: int\n ):\n\n self.module = module\n self.invocation_id = invocation_id\n # A unique id for this structure, to enable caching of graphviz calls\n self.structure_id = structure_id\n\n # Nodes are either 'Input x'/'Output x' strings or ModuleInvocationStructures\n self.inner_graph = nx.DiGraph()\n\n for i in range(input_n):\n name = f'Input {i}'\n self.inner_graph.add_node(name, memory_id=None, label=name)\n \n for i in range(output_n):\n name = f'Output {i}'\n self.inner_graph.add_node(name, memory_id=None, label=name)\n\n self.upstreams_fetched = False\n\n self.graphviz_json_cache: Optional[dict] = None\n\n def module_metadata(self) -> ExplorerMetadata:\n return self.module.torchexplorer_metadata\n\n def get_inner_structure(\n self, module: nn.Module, invocation_id: int\n ) -> Optional['ModuleInvocationStructure']:\n\n return self._inner_filter(\n lambda node: node.module == module and node.invocation_id == invocation_id\n )\n\n def get_inner_structure_from_memory_id(\n self, memory_id: int\n ) -> Optional['ModuleInvocationStructure']:\n\n return self._inner_filter(lambda node: id(node) == memory_id)\n\n def get_inner_structure_from_id(\n self, structure_id: int\n ) -> Optional['ModuleInvocationStructure']:\n\n return self._inner_filter(lambda node: node.structure_id == structure_id)\n\n def _inner_filter(self, test_fn: Callable) -> Optional['ModuleInvocationStructure']:\n for node in self.inner_graph.nodes:\n if isinstance(node, ModuleInvocationStructure):\n if test_fn(node):\n return node\n\n return None\n\n # NOTE: Overriding __str__ breaks the graphviz rendering...\n def str_impl(self) -> str:\n return f'{self.module.__class__.__name__}, Invocation {self.invocation_id}'" }, { "identifier": "is_input_node", "path": "torchexplorer/structure/structure.py", "snippet": "def is_input_node(node) -> bool:\n if not isinstance(node, str):\n return False\n return bool(re.match(r'Input \\d+', node)) or (node=='Input')" }, { "identifier": "is_io_node", "path": "torchexplorer/structure/structure.py", "snippet": "def is_io_node(node) -> bool:\n return is_input_node(node) or is_output_node(node)" }, { "identifier": "EdgeLayout", "path": "torchexplorer/render/structs.py", "snippet": "class EdgeLayout:\n path_points: list[list[float]]\n arrowhead_points: list[list[float]]\n downstream_input_index: Optional[int]\n upstream_output_index: Optional[int]" }, { "identifier": "TooltipLayout", "path": "torchexplorer/render/structs.py", "snippet": "class TooltipLayout:\n tooltip: Tooltip\n\n # Coordinates in parent of the layout this tooltip belongs to\n bottom_left_corner: list[float] = field(default_factory=lambda: [0, 0]) \n top_right_corner: list[float] = field(default_factory=lambda: [0, 0])" }, { "identifier": "NodeLayout", "path": "torchexplorer/render/structs.py", "snippet": "class NodeLayout:\n display_name: Optional[str] = None\n tooltip: Optional[TooltipLayout] = None\n\n invocation_hists: Optional[ModuleInvocationHistograms] = None\n invocation_grad_hists: Optional[ModuleInvocationHistograms] = None\n shared_hists: Optional[ModuleSharedHistograms] = None\n\n # Coordinates in parent layout\n bottom_left_corner: list[float] = field(default_factory=lambda: [0, 0]) \n top_right_corner: list[float] = field(default_factory=lambda: [0, 0]) \n\n # Inner graph data\n inner_graph_layouts: list['NodeLayout'] = (\n field(default_factory=lambda: [])\n )\n inner_graph_edges: list[EdgeLayout] = field(default_factory=lambda: [])\n\n # Data added in the _process_graph function, after everything has been layed out\n # These ids are not related to the structure_id of the ModuleInvocationStructure\n id: Optional[int] = None\n parent_id: Optional[int] = None\n # Parent stack includes current layout (this goes into the parents view in vega)\n parent_stack: Optional[list[tuple[str, int]]] = None\n child_ids: Optional[list[int]] = None" } ]

[ { "identifier": "Node", "path": "montecarlo/node.py", "snippet": "class Node:\n def __init__(self, state):\n self.state = state\n self.win_value = 0\n self.policy_value = None\n self.visits = 0\n self.parent = None\n self.children = []\n self.expanded = False\n self.player_number = None\n self.discovery_factor = 0.35\n\n def update_win_value(self, value):\n self.win_value += value\n self.visits += 1\n\n if self.parent:\n self.parent.update_win_value(value)\n\n def update_policy_value(self, value):\n self.policy_value = value\n\n def add_child(self, child):\n self.children.append(child)\n child.parent = self\n\n def add_children(self, children):\n for child in children:\n self.add_child(child)\n\n def get_preferred_child(self, root_node):\n best_children = []\n best_score = float(\"-inf\")\n\n for child in self.children:\n score = child.get_score(root_node)\n\n if score > best_score:\n best_score = score\n best_children = [child]\n elif score == best_score:\n best_children.append(child)\n\n return random.choice(best_children)\n\n def get_score(self, root_node):\n discovery_operand = (\n self.discovery_factor\n * (self.policy_value or 1)\n * sqrt(log(self.parent.visits) / (self.visits or 1))\n )\n\n win_multiplier = (\n 1 if self.parent.player_number == root_node.player_number else -1\n )\n win_operand = win_multiplier * self.win_value / (self.visits or 1)\n\n self.score = win_operand + discovery_operand\n\n return self.score\n\n def is_scorable(self):\n return self.visits or self.policy_value != None\n \n def print_node(self, f, i, root, st):\n escape = lambda x : json.dumps(x).strip('\"')\n if self.parent is None:\n f.write((' ' * i) + st + \" [label=\\\"\" + escape(self.state) + \"\\\",shape=box]\\n\")\n else:\n diff = '\\n'.join([x for x in self.state.split(\"\\n\") if x not in self.parent.state.split(\"\\n\")])\n f.write((' ' * i) + st + \" [label=\\\"\" + escape(diff) + \"\\\",shape=box]\\n\")\n\n num = 0\n for child in self.children:\n new_st = st + \"_\" + str(num)\n child.print_node(f, i + 2, root, new_st)\n f.write(' ' * i + st + \" -- \" + new_st + \"\\n\")\n num = num + 1" }, { "identifier": "MonteCarlo", "path": "montecarlo/montecarlo.py", "snippet": "class MonteCarlo:\n def __init__(self, root_node):\n self.root_node = root_node\n self.solution = None\n self.child_finder = None\n self.node_evaluator = lambda child, montecarlo: None\n self.stats_expansion_count = 0\n self.stats_failed_expansion_count = 0\n\n def make_choice(self):\n best_children = []\n most_visits = float(\"-inf\")\n\n for child in self.root_node.children:\n if child.visits > most_visits:\n most_visits = child.visits\n best_children = [child]\n elif child.visits == most_visits:\n best_children.append(child)\n\n return random.choice(best_children)\n\n def make_exploratory_choice(self):\n children_visits = map(lambda child: child.visits, self.root_node.children)\n children_visit_probabilities = [\n visit / self.root_node.visits for visit in children_visits\n ]\n random_probability = random.uniform(0, 1)\n probabilities_already_counted = 0.0\n\n for i, probability in enumerate(children_visit_probabilities):\n if probabilities_already_counted + probability >= random_probability:\n return self.root_node.children[i]\n\n probabilities_already_counted += probability\n\n def simulate(self, expansion_count=1):\n i = 0\n while expansion_count is None or i < expansion_count:\n i += 1\n\n if self.solution is not None:\n return\n\n current_node = self.root_node\n\n while current_node.expanded:\n current_node = current_node.get_preferred_child(self.root_node)\n\n self.expand(current_node)\n\n def expand(self, node):\n self.stats_expansion_count += 1\n self.child_finder(node, self)\n\n for child in node.children:\n child_win_value = self.node_evaluator(child, self)\n\n if child_win_value != None:\n child.update_win_value(child_win_value)\n\n if not child.is_scorable():\n self.random_rollout(child)\n child.children = []\n\n if len(node.children):\n node.expanded = True\n else:\n self.stats_failed_expansion_count += 1\n\n def random_rollout(self, node):\n self.child_finder(node, self)\n child = random.choice(node.children)\n node.children = []\n node.add_child(child)\n child_win_value = self.node_evaluator(child, self)\n\n if child_win_value != None:\n node.update_win_value(child_win_value)\n else:\n self.random_rollout(child)\n\n def print_tree(self, f):\n f.write(\"graph\\n{\\n\")\n self.root_node.print_node(f, 0, self.root_node, \"a\")\n f.write(\"}\\n\")" }, { "identifier": "score_func", "path": "lang.py", "snippet": "def can_be_solution(msg: str, min_lines: int, check_func=None) -> bool:\ndef find_largest_new_block(old_text: str, text: str) -> str:\ndef find_largest_new_block_code(old_code: str, code: str) -> str:" }, { "identifier": "prompt", "path": "prompts.py", "snippet": "NO_CHECK_PROOF = lambda v: True\n CHECK_PROOF = lambda v: proof_marker in v\n CHECK_PROOF2 = lambda v: v.count(proof_marker) >= 2\n CHECK_PROOF = NO_CHECK_PROOF\nNO_CHECK_CHEAT = lambda v: False\n CHECK_CHEAT = lambda v: cheat_marker in v\n CHECK_CHEAT = NO_CHECK_CHEAT\nEXTRA_CONSTANT_FOLDING = \" and performs all additions by constants\"\nEXTRA_CONSTANT_FOLDING = \"\"\ndef remove_hints2(prompt):\ndef remove_hints3(prompt):\ndef remove_hints(prompt):" }, { "identifier": "limit_depth", "path": "common.py", "snippet": "def count_depth(node, f=lambda x: x):\ndef limit_depth(node, f=lambda x: x):" }, { "identifier": "args", "path": "cmdline.py", "snippet": "class CommonArguments:\ndef get_args():" } ]

[ { "identifier": "BACKENDS_MAPPING", "path": "src/diffusers/utils/import_utils.py", "snippet": "BACKENDS_MAPPING = OrderedDict(\n [\n (\"bs4\", (is_bs4_available, BS4_IMPORT_ERROR)),\n (\"flax\", (is_flax_available, FLAX_IMPORT_ERROR)),\n (\"inflect\", (is_inflect_available, INFLECT_IMPORT_ERROR)),\n (\"onnx\", (is_onnx_available, ONNX_IMPORT_ERROR)),\n (\"opencv\", (is_opencv_available, OPENCV_IMPORT_ERROR)),\n (\"scipy\", (is_scipy_available, SCIPY_IMPORT_ERROR)),\n (\"torch\", (is_torch_available, PYTORCH_IMPORT_ERROR)),\n (\"transformers\", (is_transformers_available, TRANSFORMERS_IMPORT_ERROR)),\n (\"unidecode\", (is_unidecode_available, UNIDECODE_IMPORT_ERROR)),\n (\"librosa\", (is_librosa_available, LIBROSA_IMPORT_ERROR)),\n (\"k_diffusion\", (is_k_diffusion_available, K_DIFFUSION_IMPORT_ERROR)),\n (\"note_seq\", (is_note_seq_available, NOTE_SEQ_IMPORT_ERROR)),\n (\"wandb\", (is_wandb_available, WANDB_IMPORT_ERROR)),\n (\"omegaconf\", (is_omegaconf_available, OMEGACONF_IMPORT_ERROR)),\n (\"tensorboard\", (is_tensorboard_available, TENSORBOARD_IMPORT_ERROR)),\n (\"compel\", (is_compel_available, COMPEL_IMPORT_ERROR)),\n (\"ftfy\", (is_ftfy_available, FTFY_IMPORT_ERROR)),\n (\"torchsde\", (is_torchsde_available, TORCHSDE_IMPORT_ERROR)),\n (\"invisible_watermark\", (is_invisible_watermark_available, INVISIBLE_WATERMARK_IMPORT_ERROR)),\n ]\n)" }, { "identifier": "is_compel_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_compel_available():\n return _compel_available" }, { "identifier": "is_flax_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_flax_available():\n return _flax_available" }, { "identifier": "is_note_seq_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_note_seq_available():\n return _note_seq_available" }, { "identifier": "is_onnx_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_onnx_available():\n return _onnx_available" }, { "identifier": "is_opencv_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_opencv_available():\n return _opencv_available" }, { "identifier": "is_peft_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_peft_available():\n return _peft_available" }, { "identifier": "is_torch_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_torch_available():\n return _torch_available" }, { "identifier": "is_torch_version", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_torch_version(operation: str, version: str):\n \"\"\"\n Args:\n Compares the current PyTorch version to a given reference with an operation.\n operation (`str`):\n A string representation of an operator, such as `\">\"` or `\"<=\"`\n version (`str`):\n A string version of PyTorch\n \"\"\"\n return compare_versions(parse(_torch_version), operation, version)" }, { "identifier": "is_torchsde_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_torchsde_available():\n return _torchsde_available" }, { "identifier": "is_transformers_available", "path": "src/diffusers/utils/import_utils.py", "snippet": "def is_transformers_available():\n return _transformers_available" }, { "identifier": "get_logger", "path": "src/diffusers/utils/logging.py", "snippet": "def get_logger(name: Optional[str] = None) -> logging.Logger:\n \"\"\"\n Return a logger with the specified name.\n\n This function is not supposed to be directly accessed unless you are writing a custom diffusers module.\n \"\"\"\n\n if name is None:\n name = _get_library_name()\n\n _configure_library_root_logger()\n return logging.getLogger(name)" } ]

[ { "identifier": "Platform", "path": "unidep/platform_definitions.py", "snippet": "VALID_SELECTORS = get_args(Selector)\nPEP508_MARKERS = {\n \"linux-64\": \"sys_platform == 'linux' and platform_machine == 'x86_64'\",\n \"linux-aarch64\": \"sys_platform == 'linux' and platform_machine == 'aarch64'\",\n \"linux-ppc64le\": \"sys_platform == 'linux' and platform_machine == 'ppc64le'\",\n \"osx-64\": \"sys_platform == 'darwin' and platform_machine == 'x86_64'\",\n \"osx-arm64\": \"sys_platform == 'darwin' and platform_machine == 'arm64'\",\n \"win-64\": \"sys_platform == 'win32' and platform_machine == 'AMD64'\",\n (\"linux-64\", \"linux-aarch64\", \"linux-ppc64le\"): \"sys_platform == 'linux'\",\n (\"osx-64\", \"osx-arm64\"): \"sys_platform == 'darwin'\",\n (\n \"linux-64\",\n \"linux-aarch64\",\n \"linux-ppc64le\",\n \"osx-64\",\n \"osx-arm64\",\n ): \"sys_platform == 'linux' or sys_platform == 'darwin'\",\n}\nPLATFORM_SELECTOR_MAP: dict[Platform, list[Selector]] = {\n \"linux-64\": [\"linux64\", \"unix\", \"linux\"],\n \"linux-aarch64\": [\"aarch64\", \"unix\", \"linux\"],\n \"linux-ppc64le\": [\"ppc64le\", \"unix\", \"linux\"],\n # \"osx64\" is a selector unique to conda-build referring to\n # platforms on macOS and the Python architecture is x86-64\n \"osx-64\": [\"osx64\", \"osx\", \"macos\", \"unix\"],\n \"osx-arm64\": [\"arm64\", \"osx\", \"macos\", \"unix\"],\n \"win-64\": [\"win64\", \"win\"],\n}\nPLATFORM_SELECTOR_MAP_REVERSE: dict[Selector, set[Platform]] = {}\ndef validate_selector(selector: Selector) -> None:\ndef platforms_from_selector(selector: str) -> list[Platform]:\n def platforms(self) -> list[Platform] | None:\n def pprint(self) -> str:\n def name_with_pin(self, *, is_pip: bool = False) -> str:\nclass Spec(NamedTuple):" }, { "identifier": "dependencies_filename", "path": "unidep/utils.py", "snippet": "def dependencies_filename(folder_or_path: str | Path) -> Path:\n \"\"\"Get the path to `requirements.yaml` or `pyproject.toml` file.\"\"\"\n path = Path(folder_or_path)\n if path.is_dir():\n fname_yaml = path / \"requirements.yaml\"\n if fname_yaml.exists():\n return fname_yaml\n fname_toml = path / \"pyproject.toml\"\n if fname_toml.exists() and unidep_configured_in_toml(fname_toml):\n return fname_toml\n msg = (\n f\"File `{fname_yaml}` or `{fname_toml}` (with unidep configuration)\"\n f\" not found in `{folder_or_path}`.\"\n )\n raise FileNotFoundError(msg)\n if not path.exists():\n msg = f\"File `{path}` not found.\"\n raise FileNotFoundError(msg)\n return path" }, { "identifier": "is_pip_installable", "path": "unidep/utils.py", "snippet": "def is_pip_installable(folder: str | Path) -> bool: # pragma: no cover\n \"\"\"Determine if the project is pip installable.\n\n Checks for existence of setup.py or [build-system] in pyproject.toml.\n \"\"\"\n path = Path(folder)\n if (path / \"setup.py\").exists():\n return True\n\n # When toml makes it into the standard library, we can use that instead\n # For now this is good enough, except it doesn't handle the case where\n # [build-system] is inside of a multi-line literal string.\n pyproject_path = path / \"pyproject.toml\"\n if pyproject_path.exists():\n with pyproject_path.open(\"r\") as file:\n for line in file:\n if line.strip().startswith(\"[build-system]\"):\n return True\n return False" }, { "identifier": "parse_package_str", "path": "unidep/utils.py", "snippet": "def parse_package_str(package_str: str) -> ParsedPackageStr:\n \"\"\"Splits a string into package name, version pinning, and platform selector.\"\"\"\n # Regex to match package name, version pinning, and optionally platform selector\n name_pattern = r\"[a-zA-Z0-9_-]+\"\n version_pin_pattern = r\".*?\"\n selector_pattern = r\"[a-z0-9\\s]+\"\n pattern = rf\"({name_pattern})\\s*({version_pin_pattern})?(:({selector_pattern}))?$\"\n match = re.match(pattern, package_str)\n\n if match:\n package_name = match.group(1).strip()\n version_pin = match.group(2).strip() if match.group(2) else None\n selector = match.group(4).strip() if match.group(4) else None\n\n if selector is not None:\n for s in selector.split():\n validate_selector(cast(Selector, s))\n\n return ParsedPackageStr(\n package_name,\n version_pin,\n selector,\n )\n\n msg = f\"Invalid package string: '{package_str}'\"\n raise ValueError(msg)" }, { "identifier": "selector_from_comment", "path": "unidep/utils.py", "snippet": "def selector_from_comment(comment: str) -> str | None:\n \"\"\"Extract a valid selector from a comment.\"\"\"\n multiple_brackets_pat = re.compile(r\"#.*\\].*\\[\") # Detects multiple brackets\n if multiple_brackets_pat.search(comment):\n msg = f\"Multiple bracketed selectors found in comment: '{comment}'\"\n raise ValueError(msg)\n\n sel_pat = re.compile(r\"#\\s*\\[([^\\[\\]]+)\\]\")\n m = sel_pat.search(comment)\n if not m:\n return None\n selectors = m.group(1).strip().split()\n for s in selectors:\n validate_selector(cast(Selector, s))\n return \" \".join(selectors)" }, { "identifier": "unidep_configured_in_toml", "path": "unidep/utils.py", "snippet": "def unidep_configured_in_toml(path: Path) -> bool:\n \"\"\"Check if dependencies are specified in pyproject.toml.\n\n If a TOML parser is not available it finds `[tool.unidep]` in `pyproject.toml`.\n \"\"\"\n if HAS_TOML:\n with path.open(\"rb\") as f:\n data = tomllib.load(f)\n return bool(data.get(\"tool\", {}).get(\"unidep\", {}))\n # TODO[Bas]: will fail if defining dict in # noqa: TD004, TD003, FIX002\n # pyproject.toml directly e.g., it contains:\n # `tool = {unidep = {dependencies = ...}}`\n return any( # pragma: no cover\n line.lstrip().startswith(\"[tool.unidep\")\n for line in path.read_text().splitlines()\n )" }, { "identifier": "warn", "path": "unidep/utils.py", "snippet": "def warn(\n message: str | Warning,\n category: type[Warning] = UserWarning,\n stacklevel: int = 1,\n) -> None:\n \"\"\"Emit a warning with a custom format specific to this package.\"\"\"\n original_format = warnings.formatwarning\n warnings.formatwarning = _simple_warning_format\n try:\n warnings.warn(message, category, stacklevel=stacklevel + 1)\n finally:\n warnings.formatwarning = original_format" } ]

[ { "identifier": "select_points", "path": "utils/monai_inferers_utils.py", "snippet": "def select_points(preds, num_positive_extra=4, num_negative_extra=0, fix_extra_point_num=None):\n spacial_dim = 3\n points = torch.zeros((0, 3))\n labels = torch.zeros((0))\n pos_thred = 0.9\n neg_thred = 0.1\n \n # get pos/net indices\n positive_indices = torch.nonzero(preds > pos_thred, as_tuple=True) # ([pos x], [pos y], [pos z])\n negative_indices = torch.nonzero(preds < neg_thred, as_tuple=True)\n\n ones_idx = (preds > pos_thred).nonzero(as_tuple=True)\n if all(tmp.nelement() == 0 for tmp in ones_idx):\n # all neg\n num_positive_extra = 0\n selected_positive_point = torch.tensor([-1,-1,-1]).unsqueeze(dim=0)\n points = torch.cat((points, selected_positive_point), dim=0)\n labels = torch.cat((labels, torch.tensor([-1]).reshape(1)))\n else:\n # random select a pos point\n random_idx = torch.randint(len(positive_indices[0]), (1,))\n selected_positive_point = torch.tensor([positive_indices[i][random_idx] for i in range(spacial_dim)]).unsqueeze(dim=0)\n points = torch.cat((points, selected_positive_point), dim=0)\n labels = torch.cat((labels, torch.ones((1))))\n\n if num_positive_extra > 0:\n pos_idx_list = torch.randperm(len(positive_indices[0]))[:num_positive_extra]\n extra_positive_points = []\n for pos_idx in pos_idx_list:\n extra_positive_points.append([positive_indices[i][pos_idx] for i in range(spacial_dim)])\n extra_positive_points = torch.tensor(extra_positive_points).reshape(-1, 3)\n points = torch.cat((points, extra_positive_points), dim=0)\n labels = torch.cat((labels, torch.ones((extra_positive_points.shape[0]))))\n\n if num_negative_extra > 0:\n neg_idx_list = torch.randperm(len(negative_indices[0]))[:num_negative_extra]\n extra_negative_points = []\n for neg_idx in neg_idx_list:\n extra_negative_points.append([negative_indices[i][neg_idx] for i in range(spacial_dim)])\n extra_negative_points = torch.tensor(extra_negative_points).reshape(-1, 3)\n points = torch.cat((points, extra_negative_points), dim=0)\n labels = torch.cat((labels, torch.zeros((extra_negative_points.shape[0]))))\n # print('extra_negative_points ', extra_negative_points, extra_negative_points.shape)\n # print('==> points ', points.shape, labels)\n \n if fix_extra_point_num is None:\n left_point_num = num_positive_extra + num_negative_extra + 1 - labels.shape[0]\n else:\n left_point_num = fix_extra_point_num + 1 - labels.shape[0]\n\n for _ in range(left_point_num):\n ignore_point = torch.tensor([-1,-1,-1]).unsqueeze(dim=0)\n points = torch.cat((points, ignore_point), dim=0)\n labels = torch.cat((labels, torch.tensor([-1]).reshape(1)))\n\n return (points, labels)" }, { "identifier": "generate_box", "path": "utils/monai_inferers_utils.py", "snippet": "def generate_box(pred_pre, bbox_shift=None):\n meaning_post_label = pred_pre # [h, w, d]\n ones_idx = (meaning_post_label > 0).nonzero(as_tuple=True)\n if all(tensor.nelement() == 0 for tensor in ones_idx):\n bboxes = torch.tensor([-1,-1,-1,-1,-1,-1])\n # print(bboxes, bboxes.shape)\n return bboxes\n min_coords = [dim.min() for dim in ones_idx] # [x_min, y_min, z_min]\n max_coords = [dim.max() for dim in ones_idx] # [x_max, y_max, z_max]\n\n\n if bbox_shift is None:\n corner_min = []\n corner_max = []\n shape = meaning_post_label.shape\n for coor in min_coords:\n coor_ = max(0, coor)\n corner_min.append(coor_)\n for idx, coor in enumerate(max_coords):\n coor_ = min(shape[idx], coor)\n corner_max.append(coor_)\n corner_min = torch.tensor(corner_min)\n corner_max = torch.tensor(corner_max)\n return torch.cat((corner_min, corner_max), dim=0)\n else:\n # add perturbation to bounding box coordinates\n corner_min = []\n corner_max = []\n shape = meaning_post_label.shape\n for coor in min_coords:\n coor_ = max(0, coor + random.randint(-bbox_shift, bbox_shift))\n corner_min.append(coor_)\n for idx, coor in enumerate(max_coords):\n coor_ = min(shape[idx], coor + random.randint(-bbox_shift, bbox_shift))\n corner_max.append(coor_)\n corner_min = torch.tensor(corner_min)\n corner_max = torch.tensor(corner_max)\n return torch.cat((corner_min, corner_max), dim=0)" }, { "identifier": "BCELoss", "path": "utils/loss.py", "snippet": "class BCELoss(nn.Module):\r\n def __init__(self):\r\n super(BCELoss, self).__init__()\r\n self.criterion = nn.BCEWithLogitsLoss()\r\n\r\n def forward(self, predict, target):\r\n assert predict.shape == target.shape, 'predict & target shape do not match\\n' + str(predict.shape) + '\\n' + str(target.shape)\r\n target_ = target.clone()\r\n target_[target == -1] = 0\r\n\r\n ce_loss = self.criterion(predict, target_)\r\n\r\n return ce_loss\r" }, { "identifier": "BinaryDiceLoss", "path": "utils/loss.py", "snippet": "class BinaryDiceLoss(nn.Module):\r\n def __init__(self, smooth=1, p=2, reduction='mean'):\r\n super(BinaryDiceLoss, self).__init__()\r\n self.smooth = smooth\r\n self.p = p\r\n self.reduction = reduction\r\n\r\n def forward(self, predict, target):\r\n predict = torch.sigmoid(predict)\r\n target_ = target.clone()\r\n target_[target == -1] = 0\r\n assert predict.shape[0] == target.shape[0], \"predict & target batch size don't match\\n\" + str(predict.shape) + '\\n' + str(target.shape[0])\r\n predict = predict.contiguous().view(predict.shape[0], -1)\r\n target_ = target_.contiguous().view(target_.shape[0], -1)\r\n\r\n num = torch.sum(torch.mul(predict, target_), dim=1)\r\n den = torch.sum(predict, dim=1) + torch.sum(target_, dim=1) + self.smooth\r\n\r\n dice_score = 2*num / den\r\n dice_loss = 1 - dice_score\r\n\r\n # dice_loss_avg = dice_loss[target[:,0]!=-1].sum() / dice_loss[target[:,0]!=-1].shape[0]\r\n dice_loss_avg = dice_loss.sum() / dice_loss.shape[0]\r\n\r\n return dice_loss_avg\r" } ]

[ { "identifier": "Arguments", "path": "src/arguments.py", "snippet": "class Arguments:\n defaults: List[Any] = field(default_factory=lambda: defaults)\n\n training: SCASeq2SeqTrainingArguments = field(default_factory=lambda: SCASeq2SeqTrainingArguments(output_dir=\"?\"))\n\n # NOTE(xiaoke): to only maintain one sort of data config, we use soft links to link the data config to the train/eval config separately.\n # NOTE(xiaoke): Should be Union[List[DataArguments], DataArguments], while OmegaConf doesn't support Union. So use str to compose the configs dynamically.\n # NOTE(xiaoke): So we cannot override the args in the config file, since it will be converted to str.\n train_data: List[str] = field(default_factory=list)\n train_data_interleave_probabilities: Optional[List[float]] = field(default=None)\n train_data_overrides: List[str] = field(\n default_factory=list,\n metadata={\"help\": \"overrides for train data. \\\"train_data_overrides='[data.with_image\\=False]'\\\"\"},\n )\n\n eval_data: List[str] = field(default_factory=list)\n eval_data_overrides: List[str] = field(\n default_factory=list,\n metadata={\"help\": \"overrides for eval data. \\\"eval_data_overrides='[data.with_image\\=False]'\\\"\"},\n )\n\n model: ModelArguments = field(default_factory=ModelArguments)\n wandb: WandbArguments = field(default_factory=WandbArguments)\n\n data_transforms: Optional[DataTransformsArguments] = field(default=None)" }, { "identifier": "global_setup", "path": "src/arguments.py", "snippet": "def global_setup(\n args: DictConfig,\n) -> Tuple[Arguments, SCASeq2SeqTrainingArguments, ModelArguments]:\n \"\"\"Global setup of arguments.\"\"\"\n if args.training.output_log_dir is not None:\n output_log_dir = args.training.output_log_dir\n if not osp.exists(output_log_dir):\n os.makedirs(output_log_dir)\n # NOTE: this is a dirty hack to enable logging to a different directory\n # by default in Hydra, logging.root.handlers contains two handler: stream & file\n # NOTE: mainly used in amulet\n for handler in logging.root.handlers:\n if isinstance(handler, logging.FileHandler):\n file_path = handler.baseFilename\n file_name = osp.basename(file_path)\n external_file_path = osp.join(output_log_dir, file_name)\n logging.root.addHandler(logging.FileHandler(external_file_path))\n logger.info(f\"Add external file handler to {external_file_path}\")\n break\n\n hostname = socket.gethostname()\n logger.info(f\"Running on {hostname}\")\n\n # Convert args to the actual dataclass object, to enable methods. Need to\n # delete _n_gpu, a property that TrainingArgs init doesn't expect.\n del args.training._n_gpu\n # Dirty hack: only run post init when we're ready to convert to TrainingArgs\n args.training._run_post_init = True\n # NOTE: otherwise, do_eval will be set to True in TrainingArguments.__post_init__\n if args.training.do_eval == False and args.training.do_train == False:\n args.training.evaluation_strategy = \"no\"\n args.training.load_best_model_at_end = False\n\n training_args = OmegaConf.to_object(args.training)\n model_args = OmegaConf.to_object(args.model)\n\n if (\n isinstance(model_args, (SCAModelArguments, SCADirectDecodingModelArguments))\n and args.model.model_name_or_path is None\n ):\n # NOTE: we need to set the default value of `model_name_or_path` to None\n # otherwise, it will be set to `base_sca` by default\n raise ValueError(f\"{type(model_args)} is not supported in model cfg name.\")\n\n log_level = training_args.get_process_log_level()\n logger.setLevel(log_level)\n datasets.utils.logging.set_verbosity(log_level)\n transformers.utils.logging.set_verbosity(log_level)\n transformers.utils.logging.enable_default_handler()\n transformers.utils.logging.enable_explicit_format()\n\n # Log on each process the small summary:\n logger.warning(\n f\"Process rank: {training_args.local_rank}, device: {training_args.device},\"\n f\" log_level: {log_level} n_gpu: {training_args.n_gpu}\"\n f\" distributed training: {bool(training_args.local_rank != -1)}, 16-bits\"\n f\" training: {training_args.fp16}, bf16 training: {training_args.bf16}\"\n )\n logger.debug(f\"Training/evaluation parameters {training_args}\")\n\n return args, training_args, model_args" }, { "identifier": "prepare_datasets", "path": "src/train.py", "snippet": "def prepare_datasets(args):\n train_data = []\n for train_data_config_name in args.train_data:\n cfg = hydra.compose(config_name=f\"data/{train_data_config_name}\", overrides=args.train_data_overrides)\n train_data.append(cfg.data)\n args.train_data = train_data\n\n # NOTE(xiaoke): We should only inference one eval dataset\n if len(args.eval_data) > 1:\n logger.warning(f\"We should only inference one dataset, got {args.eval_data}\")\n eval_data = []\n for eval_data_config_name in args.eval_data:\n cfg = hydra.compose(config_name=f\"data/{eval_data_config_name}\", overrides=args.eval_data_overrides)\n eval_data.append(cfg.data)\n\n train_dataset = []\n for i, each_train_data in enumerate(train_data):\n # NOTE: add data `split` to each dataset\n each_train_data.split = \"train\"\n\n _train_dataset = instantiate(each_train_data)\n train_dataset.append(_train_dataset)\n logger.info(f\"Train Dataset [{i}]: {each_train_data}\\n{_train_dataset}\")\n\n eval_dataset = {}\n for i, each_eval_data in enumerate(eval_data):\n # NOTE: add data `split` to each dataset\n # NOTE: visual genome has validation set, but we use test set for evaluation\n if \"visual_genome.py\" in each_eval_data.path and getattr(each_eval_data, \"use_densecap_splits\", None) is True:\n logger.info(\"Using densecap splits in Visual Genome, using test split to eval\")\n each_eval_data.split = \"test\"\n\n # NOTE: refcoco has validation set, but we use test set for evaluation\n elif \"refcoco.py\" in each_eval_data.path:\n if each_eval_data.name.startswith(\"refcoco-\") or each_eval_data.name.startswith(\"refcoco+-\"):\n if each_eval_data.split is None or each_eval_data.split == \"train\":\n raise ValueError(f\"refcoco{{,+}} must have split for eval. got {each_eval_data.split}\")\n logger.info(f\"Using refcoco{{,+}}: {each_eval_data.split} split to eval\")\n elif each_eval_data.name.startswith(\"refcocog\"):\n logger.info(\"Using refcocog val split to eval\")\n each_eval_data.split = \"validation\"\n elif each_eval_data.name.startswith(\"refclef\"):\n logger.info(\"Using refclef val split to eval\")\n each_eval_data.split = \"validation\"\n\n # NOTE: coco has validation set, but it does not have test set.\n elif \"coco_instance.py\" in each_eval_data.path or \"coco_instance-local.py\" in each_eval_data.path:\n logger.info(\"Using coco val split to eval\")\n each_eval_data.split = \"validation\"\n\n elif \"objects365-local.py\" in each_eval_data.path:\n logger.info(\"Using objects365 (in fact, it is COCO) val split to eval\")\n each_eval_data.split = \"validation\"\n\n elif \"v3det-local.py\" in each_eval_data.path:\n logger.info(\"Using v3det (in fact, it is COCO) val split to eval\")\n each_eval_data.split = \"validation\"\n\n elif \"sbu-pseudo_region-local.py\" in each_eval_data.path or \"sbu-pseudo_region.py\" in each_eval_data.path:\n logger.info(\"Using sbu to eval, but it does not have test split, so we use train split\")\n each_eval_data.split = \"train\"\n\n elif \"coco_caption-pseudo_region.py\" in each_eval_data.path:\n logger.info(\"Using coco_caption (in fact, it is COCO) val split to eval\")\n each_eval_data.split = \"validation\"\n\n elif (\n \"visual_genome-densecap-local.py\" in each_eval_data.path\n or \"visual_genome-grit-local.py\" in each_eval_data.path\n ):\n logger.info(f\"Using visual_genome (They are my custom splits for GRiT and Densecap) test split to eval\")\n each_eval_data.split = \"test\"\n else:\n raise ValueError(\n f\"Unknown dataset {each_eval_data.path}, we cannot determine the split for it. Please edit `src/train.py:prepare_datasets` to add the split for it.\"\n )\n\n _eval_dataset = instantiate(each_eval_data)\n eval_dataset_name = _get_data_name(each_eval_data)\n eval_dataset[eval_dataset_name] = _eval_dataset\n logger.info(f\"Eval Dataset [{i}]: {each_eval_data}\\n{_eval_dataset}\")\n args.eval_data = eval_data # NOTE: overwrite previous eval_data\n\n if args.train_data_interleave_probabilities is not None and len(train_dataset) != len(\n args.train_data_interleave_probabilities\n ):\n raise ValueError(\n f\"train_data_interleave_probabilities must have the same length as train_data, got {len(train_dataset)} and {len(args.train_data_interleave_probabilities)}\"\n )\n # NOTE(xiaoke): Expected a list of Dataset objects or a list of IterableDataset objects.\n if len(train_dataset) > 0:\n if args.train_data_interleave_probabilities is None:\n logger.warning(\n \"train_data_interleave_probabilities is not provided, \"\n \"the resulting dataset will have max_length_datasets*nb_dataset samples. \"\n \"As we use `all_exhausted` stopping strategy which is a oversampling strategy.\"\n )\n else:\n if sum(args.train_data_interleave_probabilities) != 1.0:\n logger.info(f\"Normalize train_data_interleave_probabilities to sum to 1.0\")\n args.train_data_interleave_probabilities = [\n each_prob / sum(args.train_data_interleave_probabilities)\n for each_prob in args.train_data_interleave_probabilities\n ]\n logger.info(f\"train_data_interleave_probabilities: {args.train_data_interleave_probabilities}\")\n # NOTE(xiaoke): Accourding to `datasets/src/datasets/arrow_dataset.py:_interleave_map_style_datasets:6079` and\n # `Breadcrumbsdatasets/src/datasets/iterable_dataset.py:_interleave_iterable_datasets:2293`\n train_dataset = interleave_datasets(\n train_dataset,\n probabilities=args.train_data_interleave_probabilities,\n seed=args.training.seed,\n stopping_strategy=\"all_exhausted\",\n )\n else:\n train_dataset = None\n\n logger.info(f\"Train Dataset: {train_dataset}\")\n logger.info(f\"Eval Dataset: {eval_dataset}\")\n return train_dataset, eval_dataset" } ]

[ { "identifier": "ChatCompletionMessage", "path": "OAI/types/chat_completion.py", "snippet": "class ChatCompletionMessage(BaseModel):\n role: Optional[str] = None\n content: Optional[str] = None" }, { "identifier": "ChatCompletionRespChoice", "path": "OAI/types/chat_completion.py", "snippet": "class ChatCompletionRespChoice(BaseModel):\n # Index is 0 since we aren't using multiple choices\n index: int = 0\n finish_reason: str\n message: ChatCompletionMessage" }, { "identifier": "ChatCompletionStreamChunk", "path": "OAI/types/chat_completion.py", "snippet": "class ChatCompletionStreamChunk(BaseModel):\n id: str = Field(default_factory=lambda: f\"chatcmpl-{uuid4().hex}\")\n choices: List[ChatCompletionStreamChoice]\n created: int = Field(default_factory=lambda: int(time()))\n model: str\n object: str = \"chat.completion.chunk\"" }, { "identifier": "ChatCompletionResponse", "path": "OAI/types/chat_completion.py", "snippet": "class ChatCompletionResponse(BaseModel):\n id: str = Field(default_factory=lambda: f\"chatcmpl-{uuid4().hex}\")\n choices: List[ChatCompletionRespChoice]\n created: int = Field(default_factory=lambda: int(time()))\n model: str\n object: str = \"chat.completion\"\n usage: Optional[UsageStats] = None" }, { "identifier": "ChatCompletionStreamChoice", "path": "OAI/types/chat_completion.py", "snippet": "class ChatCompletionStreamChoice(BaseModel):\n # Index is 0 since we aren't using multiple choices\n index: int = 0\n finish_reason: Optional[str]\n delta: Union[ChatCompletionMessage, dict] = {}" }, { "identifier": "CompletionResponse", "path": "OAI/types/completion.py", "snippet": "class CompletionResponse(BaseModel):\n \"\"\"Represents a completion response.\"\"\"\n\n id: str = Field(default_factory=lambda: f\"cmpl-{uuid4().hex}\")\n choices: List[CompletionRespChoice]\n created: int = Field(default_factory=lambda: int(time()))\n model: str\n object: str = \"text_completion\"\n usage: Optional[UsageStats] = None" }, { "identifier": "CompletionRespChoice", "path": "OAI/types/completion.py", "snippet": "class CompletionRespChoice(BaseModel):\n \"\"\"Represents a single choice in a completion response.\"\"\"\n\n # Index is 0 since we aren't using multiple choices\n index: int = 0\n finish_reason: str\n logprobs: Optional[LogProbs] = None\n text: str" }, { "identifier": "UsageStats", "path": "OAI/types/common.py", "snippet": "class UsageStats(BaseModel):\n \"\"\"Represents usage stats.\"\"\"\n\n prompt_tokens: int\n completion_tokens: int\n total_tokens: int" }, { "identifier": "LoraList", "path": "OAI/types/lora.py", "snippet": "class LoraList(BaseModel):\n \"\"\"Represents a list of Lora cards.\"\"\"\n\n object: str = \"list\"\n data: List[LoraCard] = Field(default_factory=list)" }, { "identifier": "LoraCard", "path": "OAI/types/lora.py", "snippet": "class LoraCard(BaseModel):\n \"\"\"Represents a single Lora card.\"\"\"\n\n id: str = \"test\"\n object: str = \"lora\"\n created: int = Field(default_factory=lambda: int(time()))\n owned_by: str = \"tabbyAPI\"\n scaling: Optional[float] = None" }, { "identifier": "ModelList", "path": "OAI/types/model.py", "snippet": "class ModelList(BaseModel):\n \"\"\"Represents a list of model cards.\"\"\"\n\n object: str = \"list\"\n data: List[ModelCard] = Field(default_factory=list)" }, { "identifier": "ModelCard", "path": "OAI/types/model.py", "snippet": "class ModelCard(BaseModel):\n \"\"\"Represents a single model card.\"\"\"\n\n id: str = \"test\"\n object: str = \"model\"\n created: int = Field(default_factory=lambda: int(time()))\n owned_by: str = \"tabbyAPI\"\n logging: Optional[LogPreferences] = None\n parameters: Optional[ModelCardParameters] = None" }, { "identifier": "unwrap", "path": "utils.py", "snippet": "def unwrap(wrapped, default=None):\n \"\"\"Unwrap function for Optionals.\"\"\"\n if wrapped is None:\n return default\n\n return wrapped" } ]

[ { "identifier": "has_answer", "path": "eval.py", "snippet": "def has_answer(text: str, answers: list[str]) -> float:\n \"\"\"Check if text contains any of the answers.\"\"\"\n return float(any([(ans.lower() in text.lower()) for ans in answers]))" }, { "identifier": "load_dataset", "path": "utils.py", "snippet": "def load_dataset(path: str) -> list[dict]:\n \"\"\"Load dataset from JSON or JSONL file.\"\"\"\n if path.endswith(\".json\"):\n return json.load(open(path, \"r\"))\n elif path.endswith(\".jsonl\"):\n return [json.loads(line.strip()) for line in open(path, \"r\")]\n else:\n extension = path.split(\".\")[-1]\n raise ValueError(f\"File extension [{extension}] not valid.\")" }, { "identifier": "write_dataset", "path": "utils.py", "snippet": "def write_dataset(path: str, dataset: list[dict]):\n \"\"\"Write dataset to JSON or JSONL file.\"\"\"\n if path.endswith(\".json\"):\n json.dump(dataset, open(path, \"w\"))\n elif path.endswith(\".jsonl\"):\n with open(path, \"w\") as fw:\n for res_dict in dataset:\n fw.write(json.dumps(res_dict) + \"\\n\")\n else:\n extension = path.split(\".\")[-1]\n raise ValueError(f\"File extension [{extension}] not valid.\")" } ]

[ { "identifier": "Icon", "path": "gui/components/icon.py", "snippet": "class Icon(ctk.CTkImage):\n def __init__(self, icon: str, size: int | tuple[int, int]=50, themed=True):\n if isinstance(size, int):\n size = (size, size)\n\n icon_dir = path.join(path.abspath(path.dirname(__file__)), \"..\", \"..\", \"assets\", \"icons\")\n super().__init__(light_image=Image.open(path.join(icon_dir, f\"{icon}{'_light' if themed else ''}.png\")),\n dark_image=Image.open(path.join(icon_dir, f\"{icon}{'_dark' if themed else ''}.png\")),\n size=size)" }, { "identifier": "WingmenList", "path": "gui/components/wingmen_list.py", "snippet": "class WingmenList(ctk.CTkFrame):\n def __init__(self, master, wingmen, broken=False, **kwargs):\n super().__init__(master, **kwargs)\n\n self.grid_columnconfigure(2, weight=1)\n self.grid_rowconfigure(0, weight=1)\n\n count = len(wingmen)\n self.wingmen_list = []\n\n if count:\n if broken:\n intro = f\"Looks like {count} of your Wingmen {'is' if count == 1 else 'are'} not operational:\"\n else:\n intro = f\"You currently have {count} Wingm{'a' if count == 1 else 'e'}n registered\"\n self.header_label = ctk.CTkLabel(\n self, text=\"Push-to-talk Key\", text_color=(\"gray40\", \"gray55\")\n )\n self.header_label.grid(row=1, column=0, padx=10)\n self.header_label2 = ctk.CTkLabel(\n self, text=\"Wingman to activate\", text_color=(\"gray40\", \"gray55\")\n )\n self.header_label2.grid(row=1, column=2, padx=10, sticky=\"w\")\n self.intro_label = ctk.CTkLabel(self, text=intro)\n self.intro_label.grid(row=0, column=0, columnspan=4, padx=10, pady=10)\n\n\n for i, wingman in enumerate(wingmen):\n row_index = i + 2\n\n key = wingman[\"name\"] if broken else wingman.get_record_key()\n key_label = ctk.CTkLabel(self, text=key)\n key_label.grid(row=row_index, column=0, padx=10)\n\n delimiter_label = ctk.CTkLabel(self, text=\"〉\")\n delimiter_label.grid(row=row_index, column=1, padx=10)\n\n value = wingman[\"error\"] if broken else wingman.name\n value_label = ctk.CTkLabel(self, text=value)\n value_label.grid(row=row_index, column=2, padx=10, sticky=\"w\")\n self.wingmen_list.append([key_label, delimiter_label, value_label])\n else:\n if not broken:\n self.warning_label = ctk.CTkLabel(self, text=\"⚠️ WARNING ⚠️\")\n self.warning_label.grid(row=0, column=1, padx=10, pady=10)\n self.warning_msg = ctk.CTkLabel(\n self,\n text=\"Seems like you don't have any functional wingmen registered.\",\n )\n self.warning_msg.grid(row=1, column=1, padx=10, pady=0)" }, { "identifier": "Printr", "path": "services/printr.py", "snippet": "class Printr(object):\n _instance = None\n\n LILA = \"\\033[95m\"\n BLUE = \"\\033[94m\"\n CYAN = \"\\033[96m\"\n GREEN = \"\\033[92m\"\n YELLOW = \"\\033[93m\"\n RED = \"\\033[91m\"\n CLEAR = \"\\033[0m\"\n BOLD = \"\\033[1m\"\n FAINT = \"\\033[2m\"\n NORMAL_WEIGHT = \"\\033[22m\"\n UNDERLINE = \"\\033[4m\"\n END_UNDERLINE = \"\\033[24m\"\n OVERLINE = \"\\033[53m\"\n END_OVERLINE = \"\\033[55m\"\n FRAMED = \"\\033[51m\"\n ENCIRCLED = \"\\033[52m\"\n DELETE_LINE = \"\\033[2K\\033[1G\"\n PREVIOUS_LINE = \"\\033[2F\"\n\n tags = [\n # {\"tagName\": \"bold\", \"font\": \"TkTextFont bold\"},\n {\"tagName\": \"info\", \"foreground\": \"#6699ff\"},\n {\"tagName\": \"warn\", \"foreground\": \"orange\"},\n {\"tagName\": \"err\", \"foreground\": \"red\"},\n\n {\"tagName\": \"green\", \"foreground\": \"#33cc33\"},\n {\"tagName\": \"blue\", \"foreground\": \"#6699ff\"},\n {\"tagName\": \"violet\", \"foreground\": \"#aa33dd\"},\n {\"tagName\": \"grey\", \"foreground\": \"grey\"}\n ]\n\n CHANNEL = Literal[\"main\", \"error\", \"warning\", \"info\"]\n OUTPUT_TYPES = None | ctk.StringVar | ctk.CTkTextbox\n\n _message_stacks: dict[CHANNEL, list] = dict(\n main=[],\n error=[],\n warning=[],\n info=[]\n )\n\n # NOTE this is a singleton class\n def __new__(cls):\n if cls._instance is None:\n cls._instance = super(Printr, cls).__new__(cls)\n\n cls.out: dict[Printr.CHANNEL, Printr.OUTPUT_TYPES ] = dict(\n main=None,\n error=None,\n warning=None,\n info=None\n )\n return cls._instance\n\n\n def set_output(self, output_channel: CHANNEL, output_element: OUTPUT_TYPES):\n if isinstance(output_element, ctk.CTkTextbox):\n for tag in self.tags:\n output_element.tag_config(**tag)\n\n self.out[output_channel] = output_element\n\n msg_stack = self._message_stacks.get(output_channel, [])\n if len(msg_stack) > 0:\n msg = \"\\n\".join(msg_stack)\n self.print(msg, output_channel)\n # TODO: clear stack?\n for _ in range(len(msg_stack)):\n msg_stack.pop()\n\n\n\n def print(self, text, output_channel: CHANNEL = \"main\", tags=None, wait_for_gui=False, console_only=False):\n channel = self.out.get(output_channel, None)\n if channel and not console_only:\n if isinstance(channel, ctk.CTkTextbox):\n channel.configure(state=\"normal\")\n channel.insert(\"end\", f\"{text}\\n\", tags=tags)\n channel.see(\"end\")\n channel.configure(state=\"disabled\")\n else:\n # output type -> StringVar\n channel.set(text)\n elif wait_for_gui and not console_only:\n # message should only be shown in GUI\n # so add it to the queue to wait for GUI initialization\n self._message_stacks.get(output_channel, []).append(text)\n else:\n # no special output type -> terminal output\n print(text)\n\n\n def print_err(self, text, wait_for_gui=True):\n self.print(text, output_channel=\"error\", wait_for_gui=wait_for_gui)\n\n def print_warn(self, text, wait_for_gui=True):\n self.print(text, output_channel=\"warning\", wait_for_gui=wait_for_gui)\n\n def print_info(self, text, wait_for_gui=True):\n self.print(text, output_channel=\"info\", wait_for_gui=wait_for_gui)\n\n\n @staticmethod\n def clr(text, color_format):\n return f\"{color_format}{text}{Printr.CLEAR}\"\n\n @staticmethod\n def clr_print(text, color_format):\n print(Printr.clr(text, color_format))\n\n @staticmethod\n def sys_print(text, headline=\"\", color=RED, first_message=True):\n if first_message:\n print(\"\")\n if headline.strip():\n print(\n Printr.clr(f\"{Printr.BOLD}{headline}{Printr.NORMAL_WEIGHT}\", color)\n )\n else:\n print(Printr.PREVIOUS_LINE)\n print(Printr.clr(f\"⎢ {text}\", color))\n print(\"\")\n\n @staticmethod\n def err_print(text, first_message=True):\n Printr.sys_print(text, \"Something went wrong!\", first_message=first_message)\n\n @staticmethod\n def warn_print(text, first_message=True):\n Printr.sys_print(text, \"Please note:\", Printr.YELLOW, first_message)\n\n @staticmethod\n def info_print(text, first_message=True):\n Printr.sys_print(text, \"\", Printr.BLUE, first_message)\n\n @staticmethod\n def hl_print(text, first_message=True):\n Printr.sys_print(text, \"\", Printr.CYAN, first_message)\n\n @staticmethod\n def override_print(text):\n print(f\"{Printr.DELETE_LINE}{text}\")\n\n @staticmethod\n def box_start():\n print(\n f\"{Printr.CYAN}⎡{Printr.OVERLINE}⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊{Printr.END_OVERLINE}⎤\"\n )\n print(f\"⎢{Printr.CLEAR}\")\n\n @staticmethod\n def box_end():\n print(f\"{Printr.CYAN}⎢\")\n print(\n f\"⎣{Printr.UNDERLINE}⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊⑊{Printr.END_UNDERLINE}⎦{Printr.CLEAR}\"\n )\n\n @staticmethod\n def box_print(text):\n print(f\"{Printr.CYAN}⎜{Printr.CLEAR} {text}\")" } ]

[ { "identifier": "login_required", "path": "Faab/FaabJWT.py", "snippet": "def login_required(f):\n \"\"\"\n 使用functools模块的wraps装饰内部函数\n \"\"\"\n\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n try:\n if g.username == -1:\n # print('error1')\n return {'message': 'token已失效'}, 401\n elif g.username == -2:\n # print('error2')\n return {'message': 'token认证失败'}, 401\n elif g.username == -3:\n # print('error3')\n return {'message': '非法的token'}, 401\n else:\n return f(*args, **kwargs)\n except Exception as e:\n print(e)\n return {'message': '请先登录认证.'}, 401\n\n '第2种方法,在返回内部函数之前,先修改wrapper的name属性'\n # wrapper.__name__ = f.__name__\n return wrapper" }, { "identifier": "db", "path": "Faab/extensions.py", "snippet": "" } ]

[ { "identifier": "get_pipe", "path": "lcm.py", "snippet": "def get_pipe(config):\n vae_model_path = config.vae_model_path.get()\n vae_model_path = vae_model_path.replace(\"\\\\\", \"/\")\n LoRA_model_path = config.LoRA_model_path.get()\n LoRA_model_path = LoRA_model_path.replace(\"\\\\\", \"/\")\n\n if config.vae_model_path.get() != \"\":\n pipe = AutoPipelineForImage2Image.from_pretrained(\n config.generation_model_name.get(), torch_dtype=torch.float16, use_safetensors=True,\n vae = AutoencoderKL.from_single_file(vae_model_path, torch_dtype=torch.float16)\n ).to(\"cuda\")\n else:\n pipe = AutoPipelineForImage2Image.from_pretrained(\n config.generation_model_name.get(), torch_dtype=torch.float16, use_safetensors=True,\n ).to(\"cuda\")\n\n if config.LoRA_model_path.get() != \"\":\n pipe.load_lora_weights(LoRA_model_path, adapter_name=\"LoRA\")\n pipe.load_lora_weights(config.lcm_model_name.get(), adapter_name=\"lcm\")\n pipe.set_adapters([\"LoRA\", \"lcm\"], adapter_weights=[config.LoRAstrength_value, 1.0])\n pipe.fuse_lora()\n else:\n pipe.load_lora_weights(config.lcm_model_name.get(), adapter_name=\"lcm\")\n\n pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)\n\n if pipe.safety_checker is not None:\n pipe.safety_checker = lambda images, **kwargs: (images, [False])\n\n return pipe" }, { "identifier": "LCM_run", "path": "lcm.py", "snippet": "def LCM_run(config, pipe):\n global img # imgをグローバル変数として使用します\n\n window_name = \"Window Capture\"\n cv2.namedWindow(window_name, cv2.WINDOW_NORMAL)\n cv2.setWindowProperty(window_name, cv2.WND_PROP_TOPMOST, 1)\n config.running = True\n listener = keyboard.Listener(on_press=on_press)\n listener.start() # キーボードリスナーを開始\n\n try:\n while config.running:\n screenshot = config.screen_capture.capture()\n input_img_np = np.array(screenshot)\n\n generator = torch.Generator(\"cuda\").manual_seed(2500)\n input_img = Image.fromarray(input_img_np)\n\n img_pil = pipe(\n strength=config.strength_value,\n prompt=config.prompt.get(),\n image=input_img,\n num_inference_steps=config.num_inference_steps_value,\n guidance_scale=1,\n generator=generator\n ).images[0]\n\n img = np.array(img_pil)\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n cv2.imshow(window_name, img)\n\n if cv2.waitKey(1) & 0xFF == ord('q'):\n break\n finally:\n cv2.destroyAllWindows()\n listener.stop() # キーボードリスナーを停止する\n listener.join() # リスナーの完全な停止を待つ# キーボードリスナーを停止" }, { "identifier": "ScreenCapture", "path": "capture.py", "snippet": "class ScreenCapture:\n\n def __init__(self):\n self.root = tk.Tk()\n self.root.attributes('-fullscreen', True)\n self.root.attributes('-topmost', True)\n self.root.attributes('-alpha', 0.5)\n self.root.configure(bg='white')\n self.root.bind('<Escape>', lambda e: self.root.quit())\n\n self.start_position = None\n self.selection = None\n\n def on_click(self, x, y, button, pressed):\n if pressed:\n self.start_position = (x, y)\n self.selection = tk.Canvas(self.root, cursor=\"cross\", bg='black')\n self.selection.place(x=x, y=y, width=1, height=1)\n else:\n self.root.quit()\n\n def on_drag(self, x, y):\n if self.start_position:\n self.selection.place_configure(width=max(1, x - self.start_position[0]), height=max(1, y - self.start_position[1]))\n\n\n def capture(self):\n screenshot = ImageGrab.grab(bbox=(self.x0, self.y0, self.x1, self.y1))\n #screenshot = ImageGrab.grab(bbox=(self.start_position[0], self.start_position[1], self.end_position[0], self.end_position[1]))\n return screenshot\n\n\n def listen(self):\n # マウスリスナーの開始\n listener = mouse.Listener(on_click=self.on_click, on_move=self.on_drag)\n listener.start()\n\n self.root.mainloop()\n listener.stop()\n self.x0, self.y0 = self.start_position\n self.x1, self.y1 = self.selection.winfo_x() + self.selection.winfo_width(), self.selection.winfo_y() + self.selection.winfo_height()" } ]

[ { "identifier": "Conversations", "path": "src/pandora/turbo/base.py", "snippet": "class Conversations:\n def __init__(self):\n self.__data = []\n\n def list(self, offset, limit):\n return len(self.__data), self.__data[offset: limit]\n\n def clear(self):\n self.__data = []\n\n def delete(self, conversation):\n self.__data = [x for x in self.__data if conversation.conversation_id != x.conversation_id]\n\n def new(self):\n conversation = Conversation()\n self.__data.insert(0, conversation)\n\n return conversation\n\n def get(self, conversation_id):\n for x in self.__data:\n if x.conversation_id == conversation_id:\n return x\n\n return None\n\n def guard_get(self, conversation_id):\n conversation = self.get(conversation_id)\n if not conversation:\n raise Exception('Can\\'t load conversation {}'.format(conversation_id))\n\n return conversation" }, { "identifier": "UserPrompt", "path": "src/pandora/turbo/base.py", "snippet": "class UserPrompt(Prompt):\n def __init__(self, prompt_id, content, parent):\n super().__init__(prompt_id=prompt_id, role='user', content=content, parent=parent)\n\n def get_message(self, end=True):\n return {\n 'id': self.prompt_id,\n 'author': {\n 'role': self.role,\n 'name': None,\n 'metadata': {}\n },\n 'create_time': self.create_time,\n 'update_time': None,\n 'content': {\n 'content_type': 'text',\n 'parts': [self.content]\n },\n 'end_turn': None,\n 'weight': 1.0,\n 'metadata': {\n 'timestamp_': 'absolute',\n 'message_type': None\n },\n 'recipient': 'all'\n }" }, { "identifier": "Prompt", "path": "src/pandora/turbo/base.py", "snippet": "class Prompt:\n def __init__(self, prompt_id=None, role=None, content=None, parent=None):\n self.prompt_id = prompt_id or str(uuid.uuid4())\n self.parent_id = None\n self.role = role\n self.content = content\n self.children = []\n self.create_time = dt.now().timestamp()\n\n if parent:\n self.parent_id = parent.prompt_id\n parent.add_child(self.prompt_id)\n\n def add_child(self, prompt_id):\n self.children.append(prompt_id)\n\n def get_message(self, end=True):\n return None\n\n def get_info(self):\n return {\n 'id': self.prompt_id,\n 'message': self.get_message(),\n 'parent': self.parent_id,\n 'children': self.children\n }" }, { "identifier": "SystemPrompt", "path": "src/pandora/turbo/base.py", "snippet": "class SystemPrompt(Prompt):\n def __init__(self, content, parent):\n super().__init__(role='system', content=content, parent=parent)\n\n def get_message(self, end=True):\n return {\n 'id': self.prompt_id,\n 'author': {\n 'role': self.role,\n 'name': None,\n 'metadata': {}\n },\n 'create_time': self.create_time,\n 'update_time': None,\n 'content': {\n 'content_type': 'text',\n 'parts': ['']\n },\n 'end_turn': True,\n 'weight': 1.0,\n 'metadata': {},\n 'recipient': 'all'\n }" }, { "identifier": "ChatCompletion", "path": "src/pandora/openai/api.py", "snippet": "class ChatCompletion(API):\n def __init__(self, proxy=None):\n self.session = requests.Session()\n self.req_kwargs = {\n 'proxies': {\n 'http': proxy,\n 'https': proxy,\n } if proxy else None,\n 'verify': where(),\n 'timeout': 600,\n 'allow_redirects': False,\n }\n\n self.user_agent = 'pandora/{}'.format(__version__)\n\n super().__init__(proxy, self.req_kwargs['verify'])\n\n def __get_headers(self, api_key):\n return {\n 'Authorization': 'Bearer ' + api_key,\n 'User-Agent': self.user_agent,\n 'Content-Type': 'application/json',\n }\n\n def request(self, api_key, model, messages, stream=True, **kwargs):\n data = {\n 'model': model,\n 'messages': messages,\n **kwargs,\n 'stream': stream,\n }\n\n return self.__request_conversation(api_key, data, stream)\n\n def __request_conversation(self, api_key, data, stream):\n default = default_api_prefix()\n\n if api_key.startswith('fk-') or api_key.startswith('pk-'):\n prefix = default\n else:\n prefix = getenv('OPENAI_API_PREFIX', default)\n url = '{}/v1/chat/completions'.format(prefix)\n\n if stream:\n headers = {**self.__get_headers(api_key), 'Accept': 'text/event-stream'}\n return self._request_sse(url, headers, data)\n\n resp = self.session.post(url=url, headers=self.__get_headers(api_key), json=data, **self.req_kwargs)\n\n def __generate_wrap():\n yield resp.json()\n\n return resp.status_code, resp.headers, __generate_wrap()" }, { "identifier": "gpt_num_tokens", "path": "src/pandora/openai/token.py", "snippet": "def gpt_num_tokens(messages, model='gpt-3.5-turbo'):\n encoding = tiktoken.encoding_for_model(model)\n\n num_tokens = 0\n for message in messages:\n num_tokens += 4\n for key, value in message.items():\n num_tokens += len(encoding.encode(value))\n if 'name' == key:\n num_tokens -= 1\n num_tokens += 2\n\n return num_tokens" } ]

[ { "identifier": "PolestarApiException", "path": "custom_components/polestar_api/pypolestar/exception.py", "snippet": "class PolestarApiException(Exception):\n \"\"\"Base class for exceptions in this module.\"\"\"" }, { "identifier": "PolestarAuthException", "path": "custom_components/polestar_api/pypolestar/exception.py", "snippet": "class PolestarAuthException(Exception):\n \"\"\"Base class for exceptions in Auth module.\"\"\"\n\n error_code: int = None\n message: str = None\n\n def __init__(self, message, error_code) -> None:\n \"\"\"Initialize the Polestar API.\"\"\"\n super().__init__(message)\n self.error_code = error_code" }, { "identifier": "PolestarApi", "path": "custom_components/polestar_api/pypolestar/polestar.py", "snippet": "class PolestarApi:\n \"\"\"Main class for handling connections with the Polestar API.\"\"\"\n\n def __init__(self, username: str, password: str) -> None:\n \"\"\"Initialize the Polestar API.\"\"\"\n self.auth = PolestarAuth(username, password)\n self.updating = False\n self.cache_data = {}\n self.latest_call_code = None\n self._client_session = httpx.AsyncClient()\n self.next_update = None\n\n\n async def init(self):\n \"\"\"Initialize the Polestar API.\"\"\"\n try:\n await self.auth.get_token()\n\n if self.auth.access_token is None:\n return\n\n await self._get_vehicle_data()\n\n except PolestarAuthException as e:\n _LOGGER.exception(\"Auth Exception: %s\", str(e))\n\n def get_latest_data(self, query: str, field_name: str) -> dict or bool or None:\n \"\"\"Get the latest data from the Polestar API.\"\"\"\n if self.cache_data and self.cache_data[query]:\n data = self.cache_data[query]['data']\n if data is None:\n return False\n return self._get_field_name_value(field_name, data)\n\n def _get_field_name_value(self, field_name: str, data: dict) -> str or bool or None:\n if field_name is None or data is None:\n return None\n\n if '/' in field_name:\n field_names = field_name.split('/')\n for key in field_names:\n if isinstance(data, dict) and key in data:\n data = data[key]\n else:\n return None\n return data\n\n if isinstance(data, dict) and field_name in data:\n return data[field_name]\n\n return None\n\n async def _get_odometer_data(self, vin: str):\n \"\"\"\" Get the latest odometer data from the Polestar API.\"\"\"\n params = {\n \"query\": \"query GetOdometerData($vin: String!) { getOdometerData(vin: $vin) { averageSpeedKmPerHour eventUpdatedTimestamp { iso unix __typename } odometerMeters tripMeterAutomaticKm tripMeterManualKm __typename }}\",\n \"operationName\": \"GetOdometerData\",\n \"variables\": \"{\\\"vin\\\":\\\"\" + vin + \"\\\"}\"\n }\n result = await self.get_graph_ql(params)\n\n if result and result['data']:\n # put result in cache\n self.cache_data[ODO_METER_DATA] = {\n 'data': result['data'][ODO_METER_DATA], 'timestamp': datetime.now()}\n\n async def _get_battery_data(self, vin: str):\n params = {\n \"query\": \"query GetBatteryData($vin: String!) { getBatteryData(vin: $vin) { averageEnergyConsumptionKwhPer100Km batteryChargeLevelPercentage chargerConnectionStatus chargingCurrentAmps chargingPowerWatts chargingStatus estimatedChargingTimeMinutesToTargetDistance estimatedChargingTimeToFullMinutes estimatedDistanceToEmptyKm estimatedDistanceToEmptyMiles eventUpdatedTimestamp { iso unix __typename } __typename }}\",\n \"operationName\": \"GetBatteryData\",\n \"variables\": \"{\\\"vin\\\":\\\"\" + vin + \"\\\"}\"\n }\n\n result = await self.get_graph_ql(params)\n\n if result and result['data']:\n # put result in cache\n self.cache_data[BATTERY_DATA] = {\n 'data': result['data'][BATTERY_DATA], 'timestamp': datetime.now()}\n\n async def _get_vehicle_data(self):\n \"\"\"\" Get the latest vehicle data from the Polestar API.\"\"\"\n # get Vehicle Data\n params = {\n \"query\": \"query getCars { getConsumerCarsV2 { vin internalVehicleIdentifier modelYear content { model { code name __typename } images { studio { url angles __typename } __typename } __typename } hasPerformancePackage registrationNo deliveryDate currentPlannedDeliveryDate __typename }}\",\n \"operationName\": \"getCars\",\n \"variables\": \"{}\"\n }\n\n result = await self.get_graph_ql(params)\n if result and result['data']:\n # check if there are cars in the account\n if result['data'][CAR_INFO_DATA] is None or len(result['data'][CAR_INFO_DATA]) == 0:\n _LOGGER.exception(\"No cars found in account\")\n # throw new exception\n raise PolestarNoDataException(\"No cars found in account\")\n\n self.cache_data[CAR_INFO_DATA] = {\n 'data': result['data'][CAR_INFO_DATA][0], 'timestamp': datetime.now()}\n\n async def get_ev_data(self, vin: str):\n \"\"\"Get the latest ev data from the Polestar API.\"\"\"\n if self.updating:\n return\n\n if self.next_update is not None and self.next_update > datetime.now():\n _LOGGER.debug(\"Skipping update, next update at %s\", self.next_update)\n return\n\n self.updating = True\n\n try:\n if self.auth.token_expiry is None:\n raise PolestarAuthException(\"No token expiry found\", 500)\n if (self.auth.token_expiry - datetime.now()).total_seconds() < 300:\n await self.auth.get_token(refresh=True)\n except PolestarAuthException as e:\n self.latest_call_code = 500\n _LOGGER.warning(\"Auth Exception: %s\", str(e))\n self.updating = False\n return\n\n async def call_api(func):\n try:\n await func()\n except PolestarNotAuthorizedException:\n await self.auth.get_token()\n except PolestarApiException as e:\n self.latest_call_code = 500\n _LOGGER.warning('Failed to get %s data %s',\n func.__name__, str(e))\n\n await call_api(lambda: self._get_odometer_data(vin))\n await call_api(lambda: self._get_battery_data(vin))\n\n self.updating = False\n self.next_update = datetime.now() + timedelta(seconds=5)\n\n def get_cache_data(self, query: str, field_name: str, skip_cache: bool = False):\n \"\"\"\" Get the latest data from the cache.\"\"\"\n if query is None:\n return None\n\n if self.cache_data and self.cache_data.get(query):\n cache_entry = self.cache_data[query]\n data = cache_entry['data']\n if data is not None:\n if skip_cache is True or cache_entry['timestamp'] + timedelta(seconds=CACHE_TIME) > datetime.now():\n return self._get_field_name_value(field_name, data)\n return None\n\n async def get_graph_ql(self, params: dict):\n \"\"\"Get the latest data from the Polestar API.\"\"\"\n headers = {\n \"Content-Type\": \"application/json\",\n \"authorization\": f\"Bearer {self.auth.access_token}\"\n }\n\n url = \"https://pc-api.polestar.com/eu-north-1/my-star/\"\n result = await self._client_session.get(url, params=params, headers=headers)\n self.latest_call_code = result.status_code\n\n if result.status_code == 401:\n raise PolestarNotAuthorizedException(\"Unauthorized Exception\")\n\n if result.status_code != 200:\n raise PolestarApiException(f\"Get GraphQL error: {result.text}\")\n\n resultData = result.json()\n if resultData.get('errors'):\n self.latest_call_code = 500\n error_message = resultData['errors'][0]['message']\n if error_message == \"User not authenticated\":\n raise PolestarNotAuthorizedException(\"Unauthorized Exception\")\n _LOGGER.error(resultData.get('errors'))\n raise PolestarApiException(error_message)\n\n _LOGGER.debug(resultData)\n return resultData" } ]

[ { "identifier": "config", "path": "maha_tts/config.py", "snippet": "class config:\n \n semantic_model_centroids = 10000 + 1\n seed_value = 3407\n\n # Text to Semantic\n t2s_position = 4096\n langs = ['english','tamil', 'telugu', 'punjabi', 'marathi', 'hindi', 'gujarati', 'bengali', 'assamese']\n lang_index = {i:j for j,i in enumerate(langs)}\n # Semantic to acoustic\n sa_timesteps_max = 1000\n\n #Acoustic Properties\n CLIP_LENGTH = 500\n MAX_WAV_VALUE=32768.0\n filter_length=1024\n hop_length=256 #256\n window = 'hann'\n win_length=1024\n n_mel_channels=80\n sampling_rate=22050\n mel_fmin=0.0\n mel_fmax=8000.0" }, { "identifier": "load_models", "path": "maha_tts/inference.py", "snippet": "def load_models(name,device=torch.device('cpu')):\n '''\n Load pre-trained models for different components of a text-to-speech system.\n\n Args:\n device (str): The target device for model loading (e.g., 'cpu' or 'cuda').\n checkpoint_diff (str): File path to the pre-trained model checkpoint for the diffusion model.\n checkpoint_ts (str): File path to the pre-trained model checkpoint for the text-to-semantic model.\n checkpoint_voco (str): File path to the pre-trained model checkpoint for the vocoder model.\n voco_config_path (str): File path to the configuration file for the vocoder model.\n\n Returns:\n diff_model (object): Loaded diffusion model for semantic-to-acoustic tokens.\n ts_model (object): Loaded text-to-semantic model for converting text-to-semantic tokens.\n vocoder (object): Loaded vocoder model for generating waveform from acoustic tokens.\n diffuser (object): Configured diffuser object for use in the diffusion model.\n '''\n\n assert name in model_dirs, \"no model name \"+name\n\n checkpoint_diff = os.path.join(DEFAULT_MODELS_DIR,name,'s2a_latest.pt')\n checkpoint_ts = os.path.join(DEFAULT_MODELS_DIR,name,'t2s_best.pt')\n checkpoint_voco = os.path.join(DEFAULT_MODELS_DIR,'hifigan','g_02500000')\n voco_config_path = os.path.join(DEFAULT_MODELS_DIR,'hifigan','config.json')\n \n # for i in [checkpoint_diff,checkpoint_ts,checkpoint_voco,voco_config_path]:\n if not os.path.exists(checkpoint_diff) or not os.path.exists(checkpoint_ts):\n download_model(name)\n \n if not os.path.exists(checkpoint_voco) or not os.path.exists(voco_config_path):\n download_model('hifigan')\n\n diff_model = load_diff_model(checkpoint_diff,device)\n ts_model = load_TS_model(checkpoint_ts,device,name)\n vocoder = load_vocoder_model(voco_config_path,checkpoint_voco,device)\n diffuser = load_diffuser()\n\n return diff_model,ts_model,vocoder,diffuser" }, { "identifier": "load_diffuser", "path": "maha_tts/inference.py", "snippet": "def load_diffuser(timesteps = 100, guidance=3):\n '''\n Load and configure a diffuser for denoising and guidance in the diffusion model.\n\n Args:\n timesteps (int): Number of denoising steps out of 1000. Default is 100.\n guidance (int): Conditioning-free guidance parameter. Default is 3.\n\n Returns:\n diffuser (object): Configured diffuser object for use in the diffusion model.\n\n Description:\n The `load_diffuser` function initializes a diffuser with specific settings for denoising and guidance.\n '''\n betas = get_named_beta_schedule('linear',config.sa_timesteps_max)\n diffuser = SpacedDiffusion(use_timesteps=space_timesteps(1000, [timesteps]), model_mean_type='epsilon',\n model_var_type='learned_range', loss_type='rescaled_mse', betas=betas,\n conditioning_free=True, conditioning_free_k=guidance)\n diffuser.training=False\n return diffuser" }, { "identifier": "infer_tts", "path": "maha_tts/inference.py", "snippet": "def infer_tts(text,ref_clips,diffuser,diff_model,ts_model,vocoder,language=None):\n '''\n Generate audio from the given text using a text-to-speech (TTS) pipeline.\n\n Args:\n text (str): The input text to be synthesized into speech.\n ref_clips (list): A list of paths to reference audio clips, preferably more than 3 clips.\n diffuser (object): A diffusion object used for denoising and guidance in the diffusion model. It should be obtained using load_diffuser.\n diff_model: diffusion model for semantic-to-acoustic tokens.\n ts_model: text-to-semantic model for converting text-to-semantic tokens.\n vocoder: vocoder model for generating waveform from acoustic tokens.\n\n Returns:\n audio (numpy.ndarray): Generated audio waveform.\n sampling_rate (int): Sampling rate of the generated audio.\n\n Description:\n The `infer_tts` function takes input text and reference audio clips, and processes them through a TTS pipeline.\n It first performs text preprocessing and generates semantic tokens using the specified text synthesis model.\n Then, it infers mel-spectrogram features using the diffusion model and the provided diffuser.\n Finally, it generates audio from the mel-spectrogram using the vocoder.\n\n Note: The function requires properly configured diff_model, ts_model, and vocoder objects for successful TTS.\n\n Example usage:\n audio, sampling_rate = infer_tts(\"Hello, how are you?\", ref_clips, diffuser, diff_model, ts_model, vocoder)\n '''\n device = next(ts_model.parameters()).device\n text = english_cleaners(text)\n ref_mels = get_ref_mels(ref_clips)\n with torch.no_grad():\n sem_tok,_ = generate_semantic_tokens(\n text,\n ts_model,\n ref_mels,\n language,\n temp = 0.7,\n top_p= 0.8,\n top_k= 5,\n n_tot_steps = 1000,\n device = device\n )\n mel = infer_mel(diff_model,int(((sem_tok.shape[-1] * 320 / 16000) * 22050/256)+1),sem_tok.unsqueeze(0) + 1,\n normalize_tacotron_mel(ref_mels),diffuser,temperature=0.5)\n\n audio = infer_wav(mel,vocoder)\n \n return audio,config.sampling_rate" } ]

[ { "identifier": "load_jsonl", "path": "utils/basic_utils.py", "snippet": "def load_jsonl(filename):\n with open(filename, \"r\") as f:\n return [json.loads(l.strip(\"\\n\")) for l in f.readlines()]" }, { "identifier": "l2_normalize_np_array", "path": "utils/basic_utils.py", "snippet": "def l2_normalize_np_array(np_array, eps=1e-5):\n \"\"\"np_array: np.ndarray, (*, D), where the last dim will be normalized\"\"\"\n return np_array / (np.linalg.norm(np_array, axis=-1, keepdims=True) + eps)" }, { "identifier": "pad_sequences_1d", "path": "utils/tensor_utils.py", "snippet": "def pad_sequences_1d(sequences, dtype=torch.long, device=torch.device(\"cpu\"), fixed_length=None):\n \"\"\" Pad a single-nested list or a sequence of n-d array (torch.tensor or np.ndarray)\n into a (n+1)-d array, only allow the first dim has variable lengths.\n Args:\n sequences: list(n-d tensor or list)\n dtype: np.dtype or torch.dtype\n device:\n fixed_length: pad all seq in sequences to fixed length. All seq should have a length <= fixed_length.\n return will be of shape [len(sequences), fixed_length, ...]\n Returns:\n padded_seqs: ((n+1)-d tensor) padded with zeros\n mask: (2d tensor) of the same shape as the first two dims of padded_seqs,\n 1 indicate valid, 0 otherwise\n Examples:\n >>> test_data_list = [[1,2,3], [1,2], [3,4,7,9]]\n >>> pad_sequences_1d(test_data_list, dtype=torch.long)\n >>> test_data_3d = [torch.randn(2,3,4), torch.randn(4,3,4), torch.randn(1,3,4)]\n >>> pad_sequences_1d(test_data_3d, dtype=torch.float)\n >>> test_data_list = [[1,2,3], [1,2], [3,4,7,9]]\n >>> pad_sequences_1d(test_data_list, dtype=np.float32)\n >>> test_data_3d = [np.random.randn(2,3,4), np.random.randn(4,3,4), np.random.randn(1,3,4)]\n >>> pad_sequences_1d(test_data_3d, dtype=np.float32)\n \"\"\"\n if isinstance(sequences[0], list):\n if \"torch\" in str(dtype):\n sequences = [torch.tensor(s, dtype=dtype, device=device) for s in sequences]\n else:\n sequences = [np.asarray(s, dtype=dtype) for s in sequences]\n\n extra_dims = sequences[0].shape[1:] # the extra dims should be the same for all elements\n lengths = [len(seq) for seq in sequences]\n if fixed_length is not None:\n max_length = fixed_length\n else:\n max_length = max(lengths)\n if isinstance(sequences[0], torch.Tensor):\n assert \"torch\" in str(dtype), \"dtype and input type does not match\"\n padded_seqs = torch.zeros((len(sequences), max_length) + extra_dims, dtype=dtype, device=device)\n mask = torch.zeros((len(sequences), max_length), dtype=torch.float32, device=device)\n else: # np\n assert \"numpy\" in str(dtype), \"dtype and input type does not match\"\n padded_seqs = np.zeros((len(sequences), max_length) + extra_dims, dtype=dtype)\n mask = np.zeros((len(sequences), max_length), dtype=np.float32)\n\n for idx, seq in enumerate(sequences):\n end = lengths[idx]\n padded_seqs[idx, :end] = seq\n mask[idx, :end] = 1\n return padded_seqs, mask # , lengths" }, { "identifier": "span_xx_to_cxw", "path": "cg_detr/span_utils.py", "snippet": "def span_xx_to_cxw(xx_spans):\n \"\"\"\n Args:\n xx_spans: tensor, (#windows, 2) or (..., 2), each row is a window of format (st, ed)\n\n Returns:\n cxw_spans: tensor, (#windows, 2), each row is a window of format (center=(st+ed)/2, width=(ed-st))\n >>> spans = torch.Tensor([[0, 1], [0.2, 0.4]])\n >>> span_xx_to_cxw(spans)\n tensor([[0.5000, 1.0000],\n [0.3000, 0.2000]])\n >>> spans = torch.Tensor([[[0, 1], [0.2, 0.4]]])\n >>> span_xx_to_cxw(spans)\n tensor([[[0.5000, 1.0000],\n [0.3000, 0.2000]]])\n \"\"\"\n center = xx_spans.sum(-1) * 0.5\n width = xx_spans[..., 1] - xx_spans[..., 0]\n return torch.stack([center, width], dim=-1)" } ]

[ { "identifier": "approve", "path": "Branded/modules/data.py", "snippet": "async def approve(user_ud: int):\n pm = await is_approved()\n pm.append(user_ud)\n await permitdb.update_one(\n {'permit': 'protection'},\n {\n '$set': {\n 'users': pm\n }\n },\n upsert=True\n )" }, { "identifier": "disapprove", "path": "Branded/modules/data.py", "snippet": "async def disapprove(user_ud: int):\n pm = await is_approved()\n pm.remove(user_ud)\n await permitdb.update_one(\n {'permit': 'protection'},\n {\n '$set': {\n 'users': pm\n }\n },\n upsert=True\n )" }, { "identifier": "is_approved", "path": "Branded/modules/data.py", "snippet": "async def is_approved() -> list:\n pm = await permitdb.find_one({'permit': 'protection'})\n if not pm:\n return []\n return pm['users']" } ]

[ { "identifier": "prompts", "path": "fuzzomatic/tools/prompts.py", "snippet": "def load_file_contents(path):\ndef readme_prompt(readme):\ndef fix_prompt(code_snippet, error):\ndef example_prompt(example_code):\ndef unit_test_prompt(test_source_code, use_statements):\ndef unit_test_prompt_with_additional_function(\n test_function_code, additional_function_code, use_statements\n):" }, { "identifier": "llm_attempt_fix_error", "path": "fuzzomatic/approaches/common.py", "snippet": "def llm_attempt_fix_error(\n codebase_dir, target_name, code_snippet, error, remaining_attempts=2\n):\n # try to fix missing cargo dependencies deterministically\n build_success, error, code_snippet = add_missing_cargo_dependencies(\n codebase_dir, error, code_snippet, target_name\n )\n if build_success:\n fuzz_target_path = write_fuzz_target(code_snippet, codebase_dir, target_name)\n return True, fuzz_target_path\n else:\n print(\"Failed to fix cargo dependencies. Resuming...\")\n\n fix_prompt = prompts.fix_prompt(code_snippet, error)\n print(\"Asking LLM to fix the code...\")\n response = llm.ask_llm(fix_prompt)\n print(\"Response:\")\n print(response)\n code_snippet = llm.extract_fuzz_target(response, codebase_dir)\n print(\"Extracted code snippet\")\n print(\"======\")\n print(code_snippet)\n fix = True\n\n if code_snippet is not None:\n fuzz_target_path = write_fuzz_target(code_snippet, codebase_dir, target_name)\n # try to build the target\n build_success, error, built_code = build_target(codebase_dir, target_name)\n else:\n build_success = False\n error = None\n remaining_attempts = 0\n fix = False\n\n if build_success:\n return build_success, fuzz_target_path\n elif remaining_attempts > 0:\n if fix:\n print(\"Failed to fix the code. Retrying...\")\n return llm_attempt_fix_error(\n codebase_dir,\n target_name,\n built_code,\n error,\n remaining_attempts=remaining_attempts - 1,\n )\n else:\n print(\"None snippet detected\")\n return False, None\n else:\n print(\"Failed to fix the code and no more remaining attempts\")\n return False, None" }, { "identifier": "parse_cargo_doc_json", "path": "fuzzomatic/tools/cargo_doc.py", "snippet": "def parse_cargo_doc_json(path):\n with open(path) as f:\n jso = json.loads(f.read())\n\n # get functions that take only one parameter and that are public\n root = jso[\"root\"]\n index = jso[\"index\"]\n root_elem = index[root]\n root_inner_items = root_elem[\"inner\"][\"module\"][\"items\"]\n\n functions = []\n\n for elem in root_inner_items:\n path = []\n e = index[elem]\n funcs = parse_item(index, e, path)\n functions.extend(funcs)\n\n return functions" }, { "identifier": "generate_cargo_doc_json", "path": "fuzzomatic/tools/cargo_doc.py", "snippet": "def generate_cargo_doc_json(codebase_dir, root_codebase_dir=None):\n cmd = [\n \"cargo\",\n \"+nightly\",\n \"rustdoc\",\n \"--lib\",\n \"--\",\n \"--output-format\",\n \"json\",\n \"-Z\",\n \"unstable-options\",\n \"-A\",\n \"rustdoc::all\",\n ]\n\n json_file_path = None\n\n try:\n subprocess.check_call(cmd, cwd=codebase_dir)\n target_root = codebase_dir\n if root_codebase_dir is not None:\n target_root = root_codebase_dir\n target = os.path.join(target_root, \"target\", \"doc\")\n crate_name = detect_crate_name(codebase_dir)\n json_file_path = os.path.join(target, f\"{crate_name}.json\")\n if os.path.exists(json_file_path):\n return json_file_path\n else:\n for f in glob.glob(f\"{target}/*.json\"):\n json_file_path = f\n except subprocess.CalledProcessError:\n print(\"Error: failed to generate cargo doc json\")\n\n return json_file_path" }, { "identifier": "DEFAULT_TARGET_NAME", "path": "fuzzomatic/tools/constants.py", "snippet": "DEFAULT_TARGET_NAME = \"auto\"" }, { "identifier": "write_fuzz_target", "path": "fuzzomatic/tools/utils.py", "snippet": "def write_fuzz_target(code_snippet, codebase_dir, target_name):\n # write snippet to file\n fuzz_target_path = build_fuzz_target_path(codebase_dir, target_name)\n with open(fuzz_target_path, \"w\") as fout:\n fout.write(code_snippet)\n\n return fuzz_target_path" }, { "identifier": "build_target", "path": "fuzzomatic/tools/utils.py", "snippet": "def build_target(codebase_dir, target_name):\n # sanitize fuzz target\n target_path = os.path.join(\n codebase_dir, \"fuzz\", \"fuzz_targets\", f\"{target_name}.rs\"\n )\n autofix_fuzz_target(target_path)\n\n # pretty format code\n rustfmt_target(target_path)\n\n # build target\n cmd = [\n \"cargo\",\n # force usage of nightly compiler in case there's\n # a rust toolchain override in the project\n \"+nightly\",\n \"fuzz\",\n \"build\",\n target_name,\n ]\n\n built_code = None\n with open(target_path) as f:\n built_code = f.read()\n\n try:\n print(\"Building target...\")\n # do not show warnings\n env = os.environ.copy()\n env[\"RUSTFLAGS\"] = \"-A warnings\"\n\n subprocess.check_output(\n cmd, cwd=codebase_dir, stderr=subprocess.STDOUT, env=env\n )\n print(\"Build success.\")\n return True, None, built_code\n except subprocess.CalledProcessError as e:\n print(\"Failed to build fuzz target\")\n error = e.output.decode(\"utf-8\")\n print(error)\n return False, error, built_code" } ]

[ { "identifier": "FAISSGroup", "path": "myla/vectorstores/faiss_group.py", "snippet": "class FAISSGroup(VectorStore):\n def __init__(self, path: str, embeddings: Embeddings = None) -> None:\n self._path = path\n self._embeddings = embeddings\n self._faiss = _import_faiss()\n\n os.makedirs(name=self._path, exist_ok=True)\n\n # lock the vs\n self._vs_lock = threading.Lock()\n self._col_locks = {}\n\n self._data = {}\n self._indexes = {}\n self._ids = {}\n\n def create_collection(self, collection: str, schema: Dict[str, type] = None, mode=\"create\"):\n \"\"\"Create a collection.\n\n :type mode:str\n :param mode: creation mode, create: raise FAISSGroupException if exists; overwrite: drop it if exists\n \"\"\"\n col_path = os.path.join(self._path, collection)\n\n if mode == 'create' and os.path.exists(col_path):\n raise FAISSGroupException(f\"Collection exists: {collection}\")\n\n if mode == 'overwrite' and os.path.exists(col_path):\n self.drop(collection=collection)\n\n if not os.path.exists(col_path):\n os.mkdir(col_path)\n\n def add(\n self,\n collection: str,\n records: List[Record],\n embeddings_columns: Optional[List[str]] = None,\n vectors: Optional[List[List[float]]] = None,\n **kwargs\n ):\n \"\"\"Add records to the collection.\"\"\"\n group_by = kwargs.get('group_by')\n\n self._check_collection_exists(collection=collection)\n\n if records is None:\n raise ValueError(f\"Invalid records: None\")\n\n if not os.path.exists(os.path.join(self._path, collection)):\n raise FAISSGroupException(f\"Collection not exists: {collection}\")\n\n groups = self._group_records(records=records, group_by=group_by)\n\n if vectors:\n if len(vectors) != len(records):\n raise ValueError(\"The length of records must be the same as the length of vecotors.\")\n else:\n text_to_embed = []\n for r in records:\n text_to_embed.append(Record.values_to_text(r, props=embeddings_columns))\n vectors = self._embeddings.embed_batch(texts=text_to_embed, instruction=kwargs.get('instruction'))\n\n with self._get_collection_lock(collection=collection):\n data, indexes, ids = self._load(collection=collection)\n\n idx_start = len(data)\n\n # add records to data\n for r in records:\n data.append(r)\n\n for gid, g_records_ids in groups.items():\n index = indexes.get(gid)\n id_map = ids.get(gid)\n\n if not index:\n index = self._faiss.IndexFlatL2(len(vectors[0]))\n id_map = []\n indexes[gid] = index\n ids[gid] = id_map\n\n g_vectors = []\n\n for i in g_records_ids:\n g_vectors.append(vectors[i])\n id = idx_start + i\n id_map.append(id)\n\n g_vectors_npa = np.array(g_vectors, dtype=np.float32)\n self._faiss.normalize_L2(g_vectors_npa)\n index.add(g_vectors_npa)\n\n # save data\n self._save_data(collection=collection, data=data)\n gid_to_saved = groups.keys()\n for gid in gid_to_saved:\n self._save_group(collection=collection, gid=gid, index=indexes[gid], ids=ids[gid])\n\n def _group_id(self, v=None):\n if v is None or pd.isnull(v):\n v = \"\"\n if not isinstance(v, str):\n v = str(v)\n return utils.sha256(v.encode()).hex()\n\n def _group_records(self, records: List[Record], group_by: str):\n groups = {}\n\n if not group_by:\n groups[self._group_id(\"\")] = range(len(records))\n else:\n for i in range(len(records)):\n gid = records[i].get(group_by)\n gid = self._group_id(gid)\n g = groups.get(gid)\n if not g:\n g = []\n groups[gid] = g\n g.append(i)\n return groups\n\n def _save_data(self, collection, data):\n fname = os.path.join(self._path, collection, \"data.pkl\")\n with open(fname, 'wb') as f:\n pickle.dump(data, f)\n\n def _save_group(self, collection, gid, index, ids):\n index_fname = os.path.join(self._path, collection, f\"{gid}.index\")\n self._faiss.write_index(index, index_fname)\n ids_fname = os.path.join(self._path, collection, f\"{gid}.ids\")\n with open(ids_fname, 'wb') as f:\n pickle.dump(ids, f)\n\n def delete(self, collection: str, query: str):\n return super().delete(collection, query)\n\n def search(\n self,\n collection: str = None,\n query: str = None,\n vector: List = None,\n filter: Any = None,\n limit: int = 20,\n columns: Optional[List[str]] = None,\n with_vector: bool = False,\n with_distance: bool = False,\n **kwargs\n ) -> Optional[List[Record]]:\n group_ids = kwargs.get('group_ids')\n\n self._check_collection_exists(collection=collection)\n\n if not query and not vector:\n raise FAISSGroupException(\"FAISSGroup search must provide query or vector.\")\n\n if query and not vector and self._embeddings:\n vector = self._embeddings.embed(text=query, instruction=kwargs.get('instruction'))\n if not vector:\n raise FAISSGroupException(\"FAISSGroup search must provide Embeddings function.\")\n\n vector = np.array([vector], dtype=np.float32)\n self._faiss.normalize_L2(vector)\n\n if group_ids is None:\n group_ids = [self._group_id()]\n else:\n group_ids = [self._group_id(v) for v in group_ids]\n\n if filter is not None:\n filter = {\n key: [value] if not isinstance(value, list) else value for key, value in filter.items()\n }\n\n data, indexes, ids = self._load(collection=collection)\n\n r_records = []\n for gid in group_ids:\n index = indexes.get(gid)\n id_map = ids.get(gid)\n if not index or not id_map:\n raise FAISSGroupException(f\"group_id not exists: {gid}\")\n\n distances, indices = index.search(vector, limit)\n for j, i in enumerate(indices[0]):\n if i == -1:\n # This happens when not enough docs are returned.\n continue\n _id = id_map[i]\n _distance = distances[0][j]\n record = data[_id]\n record['_distance'] = float(_distance)\n\n if filter:\n if all(record.get(key) in value for key, value in filter.items()):\n r_records.append(record)\n else:\n r_records.append(record)\n\n distance_threshold = kwargs.get(\"distance_threshold\")\n if distance_threshold is not None:\n r_records = [\n r for r in r_records if r['_distance'] < distance_threshold\n ]\n\n r_records.sort(key=lambda r: r['_distance'])\n\n return r_records[:limit]\n\n def drop(self, collection: str):\n \"\"\"\"\"\"\n\n def _check_collection_exists(self, collection):\n if collection is None:\n raise ValueError(f\"Invalid collection name: {collection}\")\n if not os.path.exists(os.path.join(self._path, collection)):\n raise FAISSGroupException(f\"Collection not exists: {collection}\")\n\n def _load(self, collection: str):\n \"\"\"Load collection data.\"\"\"\n\n with self._vs_lock:\n data = self._data.get(collection)\n indexes = self._indexes.get(collection)\n ids = self._ids.get(collection)\n\n if not data:\n data = []\n indexes = {}\n ids = {}\n\n path = os.path.join(self._path, collection)\n for fname in os.listdir(path=path):\n if fname == \"data.pkl\":\n with open(os.path.join(path, fname), \"rb\") as f:\n data = pickle.load(f)\n if fname.endswith(\".index\"):\n gid = fname.replace(\".index\", \"\")\n idx = self._faiss.read_index(os.path.join(path, fname))\n indexes[gid] = idx\n\n id_map = []\n with open(os.path.join(path, f\"{gid}.ids\"), \"rb\") as f:\n id_map = pickle.load(f)\n ids[gid] = id_map\n\n self._data[collection] = data\n self._indexes[collection] = indexes\n self._ids[collection] = ids\n\n return data, indexes, ids\n\n def _unload(self, collection: str):\n \"\"\"Unload collection.\"\"\"\n with self._vs_lock:\n if collection in self._data:\n del self._data[collection]\n del self._indexes[collection]\n del self._ids[collection]\n\n return gc.collect()\n\n def _get_collection_lock(self, collection):\n with self._vs_lock:\n lock = self._col_locks.get(collection)\n if not lock:\n lock = threading.Lock()\n self._col_locks[collection] = lock\n return lock" }, { "identifier": "random_id", "path": "myla/utils.py", "snippet": "def random_id():\n return base32(sha1(uuid().bytes)).decode().lower()" }, { "identifier": "sha256", "path": "myla/utils.py", "snippet": "def sha256(s: bytes):\n m = hashlib.sha256()\n m.update(s)\n return m.digest()" } ]

[ { "identifier": "generate_music_graph", "path": "src/generate_music_graph.py", "snippet": "def generate_music_graph(\n midi_file_path,\n default_theme_file_path,\n theme_file_path,\n output_path,\n soundfont_file,\n):\n theme = Theme(theme_file_path, default_theme_file_path)\n track_events_frames = get_note_start_times_in_frames(\n midi_file_path,\n theme.frame_rate,\n squash_tracks=theme.squash_tracks,\n group_notes_by_track=theme.group_notes_by_track,\n )\n\n song_graph = create_graphviz(theme, track_events_frames)\n\n base_image, nodes, edges, offsets = parse_graph(song_graph, theme)\n\n if theme.debug_show_base_image:\n base_image.show()\n cleanup_cache_dir(get_cache_dir())\n exit()\n\n FRAMES = AnimationFrames()\n\n click.echo(\"Planning out frames...\", nl=False)\n\n for track in track_events_frames.keys():\n if theme.skip_track(track):\n continue\n curr_track = track_events_frames[track]\n curr_frame = min(curr_track) - 1\n prev_notes = None\n prev_notes_frame = None\n num_notes_processed = 0\n click.echo() # NL\n\n max_notes = len(track_events_frames[track])\n\n while num_notes_processed < max_notes and curr_frame <= max(curr_track):\n curr_frame += 1\n\n if curr_frame not in curr_track:\n continue\n\n usage = size(psutil.Process().memory_info().rss)\n click.echo(\n f\"\\r[{track}] Processing {num_notes_processed + 1} of {max_notes} notes... (memory usage={usage})\",\n nl=False,\n )\n\n num_notes_processed += 1\n curr_note_tuples = curr_track[curr_frame]\n\n # Animate the Node pulses\n for (\n current_note,\n curr_note_velocity,\n curr_note_frame_len,\n ) in curr_note_tuples:\n frames = []\n for i in range(curr_note_frame_len):\n frame = [\n animate_ellipsis_blur,\n {\n \"track\": track,\n \"points\": nodes[current_note].e_points,\n \"frame_number\": i,\n \"animation_len\": curr_note_frame_len,\n \"velocity\": curr_note_velocity,\n },\n ]\n\n frames.append(frame)\n FRAMES.add_frames_to_layer(\n f\"l2-{track}-{current_note}\", curr_frame, frames\n )\n\n if theme.pulses_only:\n continue\n\n # Animate the Chord Lines\n if len(curr_note_tuples) > 1:\n # Split notes in chord up by the frame length, cause multiple chords might be playing\n notes_in_cords = {}\n for note, velocity, frame_len in curr_note_tuples:\n if frame_len not in notes_in_cords:\n notes_in_cords[frame_len] = []\n notes_in_cords[frame_len].append(note)\n\n # For each individual chord, draw the lines\n for frame_len, all_notes in notes_in_cords.items():\n # The chord lines shoudl not overlap, so sort them according to sort order\n if theme.nodes_sorted:\n if isinstance(theme.nodes_sorted, bool):\n all_notes = sorted(\n all_notes,\n key=lambda i: int(i.split(TRACK_NOTE_DELIMITER)[1]),\n )\n else:\n all_notes = filter_and_order_custom(\n theme.nodes_sorted, all_notes\n )\n # Use `overlapping_pairs` to make the notes connect as a circle\n pairs = overlapping_pairs(all_notes)\n for a, b in pairs:\n frames = []\n for i in range(frame_len):\n if b not in edges[a]:\n continue\n frames.append(\n [\n draw_fading_bezier_curve,\n {\n \"track\": track,\n \"points\": edges[a][b].b_points,\n \"frame_number\": i,\n \"animation_len\": frame_len,\n },\n ]\n )\n FRAMES.add_frames_to_layer(\n f\"l1-{track}-{a}-{b}-line\", curr_frame, frames\n )\n\n curr_notes = [curr_note_tuple[0] for curr_note_tuple in curr_note_tuples]\n\n # Animate the \"next note\" balls\n if prev_notes:\n animation_length_in_frames = curr_frame - prev_notes_frame\n drawn_to = set()\n source_usage = {note: 0 for note in prev_notes}\n\n # New Rule: Check if there are more destinations than sources to determine max usage\n max_usage = 2 if len(curr_notes) > len(prev_notes) else 1\n\n if animation_length_in_frames / theme.frame_rate <= 10:\n for a in prev_notes:\n for b in curr_notes:\n if (\n b in drawn_to\n or (a == b and not theme.allow_self_notes(track))\n or source_usage[a] >= max_usage\n or b not in edges[a]\n ):\n continue\n\n frames = []\n for i in range(animation_length_in_frames):\n frame = [\n animate_bezier_point,\n {\n \"track\": track,\n \"points\": edges[a][b].b_points,\n \"frame_number\": i,\n \"animation_length_in_frames\": animation_length_in_frames,\n },\n ]\n\n frames.append(frame)\n FRAMES.add_frames_to_layer(\n f\"l3-{track}-{a}-{b}-balls\", prev_notes_frame, frames\n )\n drawn_to.add(b)\n source_usage[a] += 1\n\n prev_notes = curr_notes\n prev_notes_frame = curr_frame\n\n num_frames = len(FRAMES)\n if theme.debug_max_frames:\n num_frames = theme.debug_max_frames\n\n writer_context = initialize_video_writer(theme.frame_rate)\n frames_written = 0\n click.echo(\"\\nDrawing frames, writing videos...\")\n NUM_WORKERS = os.cpu_count()\n with writer_context as (writer, video_file_path):\n while frames_written < num_frames:\n with ThreadPoolExecutor(max_workers=NUM_WORKERS) as executor:\n future_to_frame = {\n executor.submit(\n process_frame,\n current_frame=i,\n base_image=base_image.copy(),\n theme=theme,\n offsets=offsets,\n FRAMES=FRAMES,\n ): i\n for i in range(\n frames_written, min(frames_written + NUM_WORKERS, num_frames)\n )\n }\n\n results = []\n for future in as_completed(future_to_frame):\n frame_index = future_to_frame[future]\n frame_image = future.result()\n results.append((frame_index, frame_image))\n\n for frame_index, frame_image in sorted(results, key=lambda x: x[0]):\n add_frame_to_video(writer, frame_image)\n frames_written += 1\n\n usage = size(psutil.Process().memory_info().rss)\n click.echo(\n f\"\\rProcessed {frames_written} of {num_frames}... (memory usage={usage})\",\n nl=False,\n )\n\n finalize_video_with_music(\n writer,\n video_file_path,\n output_path,\n midi_file_path,\n theme.frame_rate,\n soundfont_file,\n frames_written,\n )" }, { "identifier": "SOUND_FONT_FILE", "path": "src/midi_stuff.py", "snippet": "SOUND_FONT_FILE = \"assets/GeneralUser GS 1.471/GeneralUser GS v1.471.sf2\"" }, { "identifier": "DARK_THEME_FILE", "path": "src/theme_stuff.py", "snippet": "DARK_THEME_FILE = \"assets/default_theme_dark.yaml\"" }, { "identifier": "LIGHT_THEME_FILE", "path": "src/theme_stuff.py", "snippet": "LIGHT_THEME_FILE = \"assets/default_theme_light.yaml\"" } ]

[ { "identifier": "LOCAL_PROJECT_PATH", "path": "codelearn/base.py", "snippet": "LOCAL_PROJECT_PATH = os.path.join(BASE_PROJECT_PATH, \"projects\")" }, { "identifier": "Indexer", "path": "codelearn/index/indexer.py", "snippet": "class Indexer(ABC):\n @abstractmethod\n def index(self, project: Project, splitter: Splitter, embedding: Embeddings, vector_db: VectorStoreBase) -> None:\n pass" }, { "identifier": "Metadata", "path": "codelearn/index/indexer.py", "snippet": "class Metadata:\n def __init__(self, id: str, **kwargs):\n self.id = id\n self.extra_fields = {k: v for k, v in kwargs.items()}\n \n def __str__(self):\n components = [f\"id={self.id}\"]\n for field, value in self.extra_fields:\n if field and value:\n components.append(f\"{field}={value}\")\n return f\"<({', '.join(components)})>\"" }, { "identifier": "ProjectLoader", "path": "codelearn/loader/loader.py", "snippet": "class ProjectLoader(ABC):\n\n source_provider: SourceProvider\n\n @abstractmethod\n def load_project(self, project_info: Dict[str, Any]) -> Project:\n print(\"ProjectLoader load_project\")\n pass" }, { "identifier": "Project", "path": "codelearn/project/project.py", "snippet": "class Project:\n\n def __init__(self, id: str, local_dir: str, source_content: FileTree, repo_url: str = None, last_updated_time = None):\n \"\"\"\n :param name: 项目名称\n :param contents: 一个字典，其中键是文件路径，值是文件内容\n \"\"\"\n self.id = id\n self.local_dir = local_dir\n self.repo_url = repo_url\n self.contents = source_content\n self.last_updated_time = last_updated_time" }, { "identifier": "RetrieveResults", "path": "codelearn/retrieval/retriever.py", "snippet": "class RetrieveResults:\n def __init__(self, content: str, metadata: Metadata, score: float = None):\n self.content = content\n self.metadata = metadata\n self.score = score\n\n def __repr__(self):\n return f\"<RetrieveResults(content={self.content}, metadata={self.metadata}, score={self.score})>\"" }, { "identifier": "Retriever", "path": "codelearn/retrieval/retriever.py", "snippet": "class Retriever(ABC):\n \n @abstractmethod\n def retrieve(self, query: str, project: Project, top_k: int = 5, search_kwargs: Optional[dict] = None) -> List[Tuple[Document, float]]:\n pass\n\n def rank(self, query: str, results: List[RetrieveResults]):\n return results" }, { "identifier": "Splitter", "path": "codelearn/splitter/splitter.py", "snippet": "class Splitter(ABC):\n @abstractmethod\n def split(self, file_tree: FileTree) -> List[ChunkInfo]:\n pass" }, { "identifier": "ProjectStorageManager", "path": "codelearn/storage/project_storage.py", "snippet": "class ProjectStorageManager:\n def __init__(self, storage: ProjectStorage, cache: ProjectCache):\n self.storage = storage\n self.cache = cache\n\n def _fetch_from_storage(self, project_id, loader, repo_url=None, local_dir = None):\n project: Optional[ProjectModel] = self.storage.get_project(project_id, repo_url=repo_url, local_dir=local_dir)\n if not project:\n print(\"_fetch_from_storage none\")\n return None\n print(\"_fetch_from_storage load start\")\n project = loader.load_project({\n \"id\": project.id,\n \"local_dir\": project.local_dir,\n \"repo_url\": project.repo_url,\n \"last_updated_time\": project.last_updated\n })\n print(f\"_fetch_from_storage load end return project from storage, {project}\")\n return project\n\n def get_project(self, project_id, loader, repo_url=None, local_dir = None) -> Optional[Project]:\n cached_project = self.cache.get_project(project_id)\n if cached_project:\n print(\"return cached_project\")\n return cached_project\n return self._fetch_from_storage(project_id, loader, repo_url, local_dir)\n\n def store_project(self, project: Project):\n self.storage.store_project(project)\n self.cache.cached_project(project)" }, { "identifier": "VectorStoreBase", "path": "codelearn/storage/vector.py", "snippet": "class VectorStoreBase(ABC):\n \"\"\"Base VectorStorage class for VectorStore.\"\"\"\n\n @abstractmethod\n def save_local(self, vector_store: VectorStore, folder_path: str, index_name: str = \"code\"):\n pass\n\n @abstractmethod\n def load_local(\n self,\n folder_path: str,\n embeddings: Embeddings,\n index_name: str = \"code\",\n **kwargs: Any\n ) -> Optional[VectorStore]:\n pass\n\n @abstractmethod\n def embending(self, project: Project, documents: List[Document], embedding: Embeddings, vector_store: Optional[VectorStore] = None, index_name=\"code\"):\n pass" }, { "identifier": "AsyncQueue", "path": "codelearn/utils/clearn_task_queue.py", "snippet": "class AsyncQueue:\n def __init__(self):\n self.tasks = asyncio.Queue()\n\n async def add_task(self, coro):\n await self.tasks.put(coro)\n\n async def run(self):\n while True:\n task = await self.tasks.get()\n await task\n self.tasks.task_done()" }, { "identifier": "async_cleanup", "path": "codelearn/utils/clearn_task_queue.py", "snippet": "async def async_cleanup(storage_path):\n max_size = project_config.max_clean_threadshold_size\n cleaned_size = project_config.after_cleaned_threadshold_size\n current_size = get_directory_size(storage_path)\n\n if current_size > max_size:\n # 删除最近最少访问的文件\n lru_files = get_least_recently_used_files(storage_path)\n for file in lru_files:\n if current_size <= cleaned_size:\n break\n size = os.path.getsize(file)\n os.remove(file)\n current_size -= size" }, { "identifier": "sync_cleanup", "path": "codelearn/utils/clearn_task_queue.py", "snippet": "def sync_cleanup(storage_path):\n max_size = project_config.max_clean_threadshold_size\n cleaned_size = project_config.after_cleaned_threadshold_size\n current_size = get_directory_size(storage_path)\n\n if current_size > max_size:\n # 删除最近最少访问的文件\n lru_files = get_least_recently_used_files(storage_path)\n for file in lru_files:\n if current_size <= cleaned_size:\n break\n size = os.path.getsize(file)\n os.remove(file)\n current_size -= size" }, { "identifier": "LOCAL_PROJECT_PATH", "path": "codelearn/base.py", "snippet": "LOCAL_PROJECT_PATH = os.path.join(BASE_PROJECT_PATH, \"projects\")" } ]

[ { "identifier": "load_model_transform", "path": "utils/misc.py", "snippet": "def load_model_transform(model_name, pretrained_dir, img_size=224):\n print(f\"Loading {model_name}\")\n checkpoint_path = None\n transform_val = None\n if model_name == \"deit3_21k\":\n model = models_deit.deit_base_patch16_LS(img_size=img_size)\n checkpoint_path = os.path.join(pretrained_dir,\n \"deit_3_base_224_21k.pth\")\n elif model_name == \"convnext_base_21k\":\n model = models_convnextv1.convnext_base()\n checkpoint_path = os.path.join(pretrained_dir,\n \"convnext_base_22k_1k_224.pth\")\n elif model_name == \"vit_clip\":\n model, _, transform_val = open_clip.create_model_and_transforms(\n 'ViT-B-16', pretrained='laion400m_e31', force_image_size=img_size)\n model = models_clip.CLIPModel(model=model, model_name='ViT-B-16')\n checkpoint_path = None\n elif model_name == \"convnext_clip\":\n model, _, transform_val = open_clip.create_model_and_transforms(\n 'convnext_base',\n pretrained='laion400m_s13b_b51k',\n force_image_size=img_size)\n model = models_clip.CLIPModel(model=model, model_name='convnext_base')\n checkpoint_path = None\n\n if checkpoint_path is not None:\n checkpoint = torch.load(checkpoint_path)\n state_dict = checkpoint['model']\n if img_size != 224 and model_name == 'deit3_21k':\n state_dict = interpolate_pos_embed(model, state_dict)\n msg = model.load_state_dict(state_dict, strict=False)\n print(msg)\n assert set(checkpoint['model'].keys()) == set(\n model.state_dict().keys())\n assert len(msg.missing_keys) == 0 and len(\n msg.unexpected_keys\n ) == 0, \"Some keys in the state dict do not match\"\n\n return model, transform_val" }, { "identifier": "evaluate", "path": "inference/modelvshuman/evaluation/evaluate.py", "snippet": "IMAGENET_LABEL_FILE = pjoin(c.CODE_DIR, \"evaluation\", \"imagenet_labels.txt\")\ndef print_performance_to_csv(model_name,\n dataset_name,\n performance,\n metric_name,\n data_parent_dir=c.PERFORMANCES_DIR):\ndef print_predictions_to_console(softmax_output,\n top_n=5,\n labels_path=IMAGENET_LABEL_FILE):\n def __init__(self, model_name, dataset, data_parent_dir=c.RAW_DATA_DIR):\n def create_session_csv(self, session):\n def print_batch_to_csv(self, object_response, batch_targets, paths):\nclass ResultPrinter():" }, { "identifier": "load_dataset", "path": "inference/modelvshuman/utils.py", "snippet": "def load_dataset(name, *args, **kwargs):\n default_kwargs = {\"batch_size\": 16, \"num_workers\": 4}\n kwargs = {**default_kwargs, **kwargs}\n logger.info(f\"Loading dataset {name}\")\n supported_datasets = dataset_module.list_datasets()\n module_name = supported_datasets.get(name, None)\n if module_name is None:\n raise NameError(\n f\"Dataset {name} is not supported, \"\n f\"please select from {list(supported_datasets.keys())}\")\n elif os.path.exists(join(c.DATASET_DIR, name)):\n return eval(f\"dataset_module.{module_name}\")(*args, **kwargs)\n elif try_download_dataset_from_github(name):\n return eval(f\"dataset_module.{module_name}\")(*args, **kwargs)\n else:\n raise NotImplementedError(\n f\"Dataset {name} not available for download, please obtain the dataset \"\n f\"yourself and save it to {c.DATASET_DIR}\")" }, { "identifier": "load_model", "path": "inference/modelvshuman/utils.py", "snippet": "def load_model(model_name, *args):\n if model_name in zoomodels.__dict__:\n model = eval(\"pytorch_model_zoo.model_pytorch\")(model_name, *args)\n framework = 'pytorch'\n else:\n model = eval(f\"pytorch_model_zoo.model_timm\")(model_name, *args)\n framework = 'pytorch'\n return model, framework" } ]

[ { "identifier": "hf_datasets_root", "path": "anchor.py", "snippet": "" }, { "identifier": "TokenizedForStyleRightPad", "path": "tasks/loader.py", "snippet": "class TokenizedForStyleRightPad(Dataset):\n def __init__(self, data, tok: PreTrainedTokenizer, prompt_fn, mode = 'eval', no_padding=False, prefix=''):\n # data: [query: str, choices: list(str)]\n self.tok = tok\n self.prompt_fn = prompt_fn\n self.references = None\n self.max_length = self._find_max_length(data, mode=mode)\n if mode == 'ft':\n self.data = self._build_ft_data(data)\n elif mode == 'eval':\n self.data, self.references = self._build_eval_data(data, no_padding=no_padding, prefix=prefix)\n else:\n raise NotImplementedError\n logger.info(f\"Tokenization finished: {len(self.data)}, max_length={self.max_length}\")\n\n def _find_max_length(self, data, mode=eval):\n max_len = 0\n\n def tok_len(t):\n return len(self.tok.encode(t))\n\n for ex in tqdm(data, desc=\"Data preprocessing(1/2)\"):\n query = ex[\"query\"]\n if mode == 'eval':\n len_query = len(self.prompt_fn(query)[0])\n elif mode == 'ft':\n len_query = len(self.prompt_fn(query)[1])\n else:\n raise NotImplementedError\n max_len = max(max_len, len_query)\n return max_len\n\n def _build_eval_data(self, data, no_padding=False, prefix=''):\n processed = []\n references = []\n for ex in tqdm(data, desc=\"Data preprocessing(2/2)\"):\n query = ex[\"query\"]\n processed_input = self.prompt_fn(query, return_reference = True, Instruction = prefix)\n t_query, t_full, t_reference = processed_input\n processed_input = self.tokenize(t_full, t_query, no_padding=no_padding)\n processed.append(processed_input)\n references.append(t_reference)\n\n logger.info(\"Style dataset: finish!\")\n return processed, references\n\n def _build_ft_data(self, data):\n processed = []\n for ex in tqdm(data, desc=\"Data preprocessing(2/2)\"):\n query = ex[\"query\"]\n processed_input = self.prompt_fn(query)\n t_query, t_full = processed_input\n processed_input = self.tokenize(t_query, t_full)\n processed.append(processed_input)\n\n logger.info(\"Finetuning dataset: finish!\")\n return processed\n\n def tokenize_demonstration(self, demonstration):\n e = self.tok(demonstration)\n return torch.LongTensor(e[\"input_ids\"]), torch.LongTensor(e[\"attention_mask\"]) # no padding\n\n def tokenize_each_demonstration(self, demonstration_list, dataset_name=None):\n tokenized_demonstration_list = []\n for exp_id in range(len(demonstration_list)):\n demonstration_list[exp_id] = (demonstration_list[exp_id][0].strip(\" .\").strip(\".\"), demonstration_list[exp_id][1].strip(\" .\").strip(\".\"))\n\n e_original = self.tok(demonstration_list[exp_id][0]) \n e_rewrite = self.tok(demonstration_list[exp_id][1])\n tokenized_demonstration_list.append((e_original, e_rewrite)) \n return tokenized_demonstration_list\n\n def tokenize(self, only_query, full_text, no_padding = False):\n tok_only_query = self.tok(only_query, add_special_tokens=False)\n tok_full_no_padding = self.tok(full_text, add_special_tokens=False)\n tok_full = self.tok(\n full_text,\n padding=\"max_length\",\n max_length=self.max_length,\n add_special_tokens=False,\n ) # <pad> is not a special token\n\n if no_padding: \n e = {\n \"input_ids\": tok_full_no_padding.input_ids,\n \"attention_mask\": tok_full_no_padding.attention_mask,\n }\n else:\n e = {\n \"input_ids\": tok_full.input_ids,\n \"attention_mask\": tok_full.attention_mask,\n }\n\n return e\n\n def __len__(self):\n return len(self.data)\n\n def __getitem__(self, idx):\n\n es = self.data[idx]\n\n if self.references:\n return torch.LongTensor(es[\"input_ids\"]), torch.LongTensor(es[\"attention_mask\"]), self.references[idx]\n else:\n return es" }, { "identifier": "RandomContext", "path": "utils/rng_ctx.py", "snippet": "class RandomContext:\n \"\"\"Save and restore state of PyTorch, NumPy, Python RNGs.\"\"\"\n\n def __init__(self, seed=None):\n outside_state = RandomState()\n\n random.seed(seed)\n np.random.seed(seed)\n if seed is None:\n torch.manual_seed(random.randint(-sys.maxsize - 1, sys.maxsize))\n else:\n torch.manual_seed(seed)\n # torch.cuda.manual_seed_all is called by torch.manual_seed\n self.inside_state = RandomState()\n\n outside_state.restore()\n\n self._active = False\n\n def __enter__(self):\n if self._active:\n raise Exception(\"RandomContext can be active only once\")\n\n self.outside_state = RandomState()\n self.inside_state.restore()\n self._active = True\n\n def __exit__(self, exception_type, exception_value, traceback):\n self.inside_state = RandomState()\n self.outside_state.restore()\n self.outside_state = None\n\n self._active = False" }, { "identifier": "EmptyContext", "path": "utils/rng_ctx.py", "snippet": "class EmptyContext:\n def __enter__(self):\n pass\n\n def __exit__(self, exc_type, exc_val, exc_tb):\n pass" }, { "identifier": "PCA", "path": "utils/pca.py", "snippet": "class PCA(nn.Module):\n def __init__(self, n_components):\n super().__init__()\n self.n_components = n_components\n\n @torch.no_grad()\n def fit(self, X):\n n, d = X.size()\n if self.n_components is not None:\n d = min(self.n_components, d)\n self.register_buffer(\"mean_\", X.mean(0, keepdim=True))\n Z = X - self.mean_ # center\n U, S, Vh = torch.linalg.svd(Z, full_matrices=False)\n Vt = Vh\n U, Vt = svd_flip(U, Vt)\n self.register_buffer(\"components_\", Vt[:d])\n return self\n\n def forward(self, X):\n return self.transform(X)\n\n def transform(self, X):\n assert hasattr(self, \"components_\"), \"PCA must be fit before use.\"\n return torch.matmul(X - self.mean_, self.components_.t())\n\n def fit_transform(self, X):\n self.fit(X)\n return self.transform(X)\n\n def inverse_transform(self, Y):\n assert hasattr(self, \"components_\"), \"PCA must be fit before use.\"\n return torch.matmul(Y, self.components_) + self.mean_" }, { "identifier": "modified_forward_context_manager", "path": "utils/context_manager.py", "snippet": "def modified_forward_context_manager(model, forward_modifiers=()):\n context_manager = CombinedContextManager([*forward_modifiers])\n return context_manager" }, { "identifier": "traced_forward_context_manager", "path": "utils/context_manager.py", "snippet": "def traced_forward_context_manager(model, with_submodules=False):\n forward_trace = ForwardTrace()\n context_manager = ForwardTracer(model, forward_trace, with_submodules=with_submodules)\n return context_manager, forward_trace" } ]

[ { "identifier": "service", "path": "src/model_inference.py", "snippet": "def service(queue, event):\n # Configure the logging settings\n logging.basicConfig(\n level=logging.DEBUG,\n format=\"%(asctime)s - %(levelname)s - %(message)s\",\n filename=join(\"logs\", \"model.log\"),\n filemode=\"w\",\n )\n logger = logging.getLogger(__name__)\n\n # Checking for GPU\n device, device_name, torch_dtype = find_gpu_config(logger)\n\n # Setting cache dir\n local_cache_dir = join(\".\", \"model\")\n\n # Creating model\n model = AutoModelForSpeechSeq2Seq.from_pretrained(\n MODEL_ID,\n torch_dtype=torch_dtype,\n low_cpu_mem_usage=True,\n use_safetensors=True,\n cache_dir=local_cache_dir,\n )\n model.to(device)\n\n # Makes inference faster for transformers\n if \"cuda\" in device.type or \"cpu\" in device.type:\n from optimum.bettertransformer import BetterTransformer\n\n model = BetterTransformer.transform(model)\n\n # Making pipeline for inference\n processor = AutoProcessor.from_pretrained(MODEL_ID, cache_dir=local_cache_dir)\n\n model_pipe = pipeline(\n \"automatic-speech-recognition\",\n model=model,\n tokenizer=processor.tokenizer,\n feature_extractor=processor.feature_extractor,\n max_new_tokens=128,\n chunk_length_s=15,\n batch_size=16,\n torch_dtype=torch_dtype,\n device=device,\n )\n\n # Checking if GPU or CPU used\n if device_name:\n print(f\"\\n\\n\\033[1m{MODEL_ID}\\033[0m loaded to {device_name}\\n\\n\")\n else:\n print(\n f\"\\n\\033[1m{MODEL_ID}\\033[0m loaded to physical memory and CPU is used.\\n\"\n + \"WARNING: Unfortunatly these models are not optimal to be computed on CPU!\\n\\n\"\n )\n del device, torch_dtype, local_cache_dir, processor\n\n # Telling parent that model is loaded\n event.set()\n # To make sure event is cleared before model inference\n sleep(1)\n\n # Make sure event is cleared before then\n try:\n while 1:\n # Waits in standy for inference, no need for this.\n # event.wait()\n\n # Get audio bytes from queue\n audio_bytes = queue.get(block=True)\n t0 = time()\n\n # Transcribing.\n result = model_pipe(audio_bytes)\n logger.info(f\"Time for inference: {time() - t0:.4f} seconds\")\n\n # Process text\n processed_text = process_text(result[\"text\"])\n\n # Write text\n WRITE(processed_text)\n\n # Action report\n speech_to_text_time = time() - t0\n print(\n f\"\\nPrinted text: {result['text']}\\nSpeech-to-text time: {speech_to_text_time:.3f}s\\n\"\n )\n\n # Resetting\n logger.debug(f\"Result: {result}\")\n event.clear()\n\n except KeyboardInterrupt:\n print(\"\\n\\033[92m\\033[4mmodel_inference.py\\033[0m \\033[92mprocess ended\\033[0m\")\n except Exception as e:\n logger.error(f\"Exception hit: {e}\")\n print(\"\\n\\033[91m\\033[4mmodel_inference.py\\033[0m \\033[91mprocess ended\\033[0m\")\n exit(1)\n finally:\n pass" }, { "identifier": "run_listener", "path": "src/funcs.py", "snippet": "def run_listener(child_pipe, start_event, model_event):\n \"\"\"\n Runs the key listener based on the OS.\n\n Args:\n child_pipe (multiprocessing.Pipe): Pipe for communication with the child process\n start_event (multiprocessing.Event): Event to tell the child process that the model is loaded\n model_event (multiprocessing.Event): Event to tell the child process that the model is loaded\n\n Returns:\n None\n \"\"\"\n # Differentiate between windows and linux\n if system() == \"Windows\":\n from src.key_listener_win import Listener\n else:\n from src.key_listener import Listener\n\n a = Listener(child_pipe, start_event, model_event)\n a.run()" }, { "identifier": "get_audio", "path": "src/funcs.py", "snippet": "def get_audio():\n \"\"\"Creates the audio stream for recording audio from the microphone.\"\"\"\n\n audio = PyAudio()\n stream_input = audio.open(\n format=paInt16,\n channels=1,\n rate=44100,\n input=True,\n frames_per_buffer=1024,\n )\n\n return audio, stream_input" }, { "identifier": "create_sound_file", "path": "src/funcs.py", "snippet": "def create_sound_file(file_name=\"tmp.wav\"):\n \"\"\"Creates a sound file for writing\"\"\"\n # Copying soundbyte for debugging purposes\n sound_file = wave.open(file_name, \"wb\")\n sound_file.setnchannels(1)\n sound_file.setsampwidth(2) # 2 bytes = 16 bits p\n sound_file.setframerate(44100)\n\n return sound_file" }, { "identifier": "pcm_to_wav", "path": "src/funcs.py", "snippet": "def pcm_to_wav(input_pcm):\n \"\"\"\n Converts PCM bytes to WAV bytes so that the HuggingFace pipeline receives\n bytes that ffmpeg could interpret.\n\n Args:\n input_pcm (bytes): PCM bytes from pyaudio\n\n Returns:\n wav_data (bytes): WAV bytes\n \"\"\"\n with io.BytesIO() as wav_file:\n wav_writer = wave.open(wav_file, \"wb\")\n\n try:\n wav_writer.setframerate(44100)\n wav_writer.setsampwidth(2)\n wav_writer.setnchannels(1)\n wav_writer.writeframes(input_pcm)\n wav_data = wav_file.getvalue()\n except Exception:\n logger.error(f\"Exception on pcm_to_wav: {traceback.format_exc()}\")\n finally:\n wav_writer.close()\n\n return wav_data" } ]

[ { "identifier": "Grid", "path": "grid.py", "snippet": "class Grid:\n def __init__(self, n):\n self.n = n * 2\n self.grid = [[\" \"] * self.n, [\" \"] * self.n]\n\n def add_level(self):\n self.grid.append([\" \"] * self.n)\n self.grid.append([\" \"] * self.n)\n\n def add_subtree(self, level, start, end, s):\n if s in [\"W\", \"m\", \"d\"]:\n self.grid[level * 2 ][start] = VERT\n self.grid[level * 2 + 1][start] = s\n return\n if (level + 1) * 2 > len(self.grid):\n self.add_level()\n mid = (start + end) // 2\n self.grid[level * 2][start ] = START\n self.grid[level * 2][end ] = END\n self.grid[level * 2][start + 1:end ] = list(HORIZ * (end - start -1 ))\n self.grid[level * 2][(start + end) // 2] = MID\n self.grid[level * 2 + 1][mid - len(s) // 2:mid - len(s) // 2 + len(s)] = list(s)\n\n def fill_in_vertical_bars(self):\n for column in range(0, self.n):\n found_start_end = False\n for row in reversed(range(len(self.grid))):\n c = self.grid[row][column]\n if c in [START, END]:\n found_start_end = True\n elif found_start_end:\n if c == \" \":\n self.grid[row][column] = \"⋮\" # │ alternative\n else:\n found_start_end = False\n\n # combinator chain sequence\n def ccs(self):\n first_two = \"\".join(\"\".join(row).strip()[0:2] for row in self.grid)\n no_bars = \"\".join(c for c in first_two if c not in \"─└ ⋮┬│\")\n while \"h₁\" in no_bars:\n no_bars = no_bars.replace(\"h₁\", \"\")\n return no_bars\n\n def display(self, indent = 0):\n for row in self.grid:\n print(\" \" * indent + \"\".join(row))" }, { "identifier": "Chain", "path": "utils.py", "snippet": "class Chain(Enum):\n MONADIC = 1\n DYADIC = 2" }, { "identifier": "Quick", "path": "utils.py", "snippet": "class Quick(Enum):\n QUICK = 3\n EACH = 10\n FLIP = 50" }, { "identifier": "Separator", "path": "utils.py", "snippet": "class Separator(Enum):\n MONADIC = 20\n DYADIC = 21" } ]

[ { "identifier": "CopyBookmarkURL", "path": "tinboard/messages/commands.py", "snippet": "class CopyBookmarkURL(Command):\n \"\"\"Copy the URL for the bookmark to the clipboard.\"\"\"" }, { "identifier": "EditBookmark", "path": "tinboard/messages/commands.py", "snippet": "class EditBookmark(Command):\n \"\"\"Edit the current bookmark.\"\"\"" }, { "identifier": "ToggleBookmarkRead", "path": "tinboard/messages/commands.py", "snippet": "class ToggleBookmarkRead(Command):\n \"\"\"Toggle the read status of the current bookmark.\"\"\"" }, { "identifier": "ToggleBookmarkPublic", "path": "tinboard/messages/commands.py", "snippet": "class ToggleBookmarkPublic(Command):\n \"\"\"Toggle the public status of the current bookmark.\"\"\"" }, { "identifier": "Bookmark", "path": "tinboard/widgets/bookmarks.py", "snippet": "class Bookmark(Option):\n \"\"\"An individual bookmark.\"\"\"\n\n PRIVATE_ICON: Final[str] = Emoji.replace(\":lock:\")\n \"\"\"The icon to use for a private bookmark.\"\"\"\n\n UNREAD_ICON: Final[str] = Emoji.replace(\":see-no-evil_monkey:\")\n \"\"\"The icon to use for an unread bookmark.\"\"\"\n\n def __init__(self, data: BookmarkData) -> None:\n \"\"\"Initialise the bookmark.\n\n Args:\n data: The bookmark data gathered from the server.\n \"\"\"\n self._data = data\n super().__init__(self.prompt, id=data.hash)\n\n @property\n def tags(self) -> list[str]:\n \"\"\"The tags of the bookmark, as a list.\"\"\"\n return self._data.tags.split()\n\n @property\n def prompt(self) -> Group:\n \"\"\"The prompt for the bookmark.\"\"\"\n # Create the title and icons line.\n title = Table.grid(expand=True)\n title.add_column(ratio=1)\n title.add_column(justify=\"right\")\n title.add_row(\n self._data.description,\n f\" {'' if self._data.shared else self.PRIVATE_ICON}{self.UNREAD_ICON if self._data.to_read else ''}\",\n )\n # Create the details line.\n details = Table.grid(expand=True)\n details.add_column(ratio=1)\n details.add_column()\n details.add_row(\n f\"[dim][i]{naturaltime(self._data.time)}[/][/]\",\n f\"[dim]{', '.join(sorted(self.tags, key = str.casefold))}[/]\",\n )\n # Combine them and add a rule afterwards.\n return Group(title, details, Rule(style=\"dim\"))\n\n def is_all(self, *checks: Callable[[\"Bookmark\"], bool]) -> bool:\n \"\"\"Does this bookmark pass all the given tests?\n\n Args:\n checks: The checks to run against the bookmark.\n\n Returns:\n `True` if all tests pass, `False` if not.\n \"\"\"\n return all(check(self) for check in checks)\n\n def is_tagged(self, *tags: str) -> bool:\n \"\"\"Is this bookmark tagged with the given tags?\n\n Args:\n tags: The tags to check for.\n\n Returns:\n `True` if the bookmark has all the tags, `False` if not.\n \"\"\"\n return {tag.casefold() for tag in tags}.issubset(\n {tag.casefold() for tag in self.tags}\n )\n\n def has_text(self, search_text: str) -> bool:\n \"\"\"Does the bookmark contain the given text?\n\n Note that this is a case-insensitive test.\n \"\"\"\n return (\n search_text.casefold()\n in f\"{self._data.description} {self._data.extended} {self._data.tags}\".casefold()\n )\n\n @classmethod\n def from_json(cls, data: dict[str, Any]) -> \"Bookmark\":\n \"\"\"Create a bookmark from some JSON data.\n\n Args:\n data: The data to create the bookmark from.\n\n Returns:\n The `Bookmark` instance.\n \"\"\"\n if \"time\" in data:\n data[\"time\"] = datetime.fromisoformat(data[\"time\"])\n return cls(BookmarkData(**data))\n\n @property\n def data(self) -> BookmarkData:\n \"\"\"The bookmark as the underlying bookmark data.\"\"\"\n return self._data\n\n @data.setter\n def data(self, data: BookmarkData) -> None:\n self._data = data\n self.set_prompt(self.prompt)" }, { "identifier": "InlineTags", "path": "tinboard/widgets/tags.py", "snippet": "class InlineTags(Tags):\n \"\"\"A version of the `Tags` widget intended to embed in another.\"\"\"\n\n DEFAULT_CSS = \"\"\"\n InlineTags > .option-list--option {\n padding: 0;\n }\n \"\"\"\n\n _ICON: Final[str] = Emoji.replace(\":bookmark: \")\n \"\"\"The icon to show before tags.\"\"\"\n\n def _prompt(self, tag: str, count: int) -> RenderableType:\n \"\"\"A prompt for the given tag.\n\n Args:\n The tag to build a prompt for.\n\n Returns:\n The prompt for the tag.\n \"\"\"\n del count\n return f\"{self._ICON} {tag}\"" } ]

[ { "identifier": "save_imgs", "path": "utils.py", "snippet": "def save_imgs(img, msk, msk_pred, i, save_path, datasets, threshold=0.5, test_data_name=None):\r\n img = img.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n img = img / 255. if img.max() > 1.1 else img\r\n if datasets == 'retinal':\r\n msk = np.squeeze(msk, axis=0)\r\n msk_pred = np.squeeze(msk_pred, axis=0)\r\n else:\r\n msk = np.where(np.squeeze(msk, axis=0) > 0.5, 1, 0)\r\n msk_pred = np.where(np.squeeze(msk_pred, axis=0) > threshold, 1, 0) \r\n\r\n plt.figure(figsize=(7,15))\r\n\r\n plt.subplot(3,1,1)\r\n plt.imshow(img)\r\n plt.axis('off')\r\n\r\n plt.subplot(3,1,2)\r\n plt.imshow(msk, cmap= 'gray')\r\n plt.axis('off')\r\n\r\n plt.subplot(3,1,3)\r\n plt.imshow(msk_pred, cmap = 'gray')\r\n plt.axis('off')\r\n\r\n if test_data_name is not None:\r\n save_path = save_path + test_data_name + '_'\r\n plt.savefig(save_path + str(i) +'.png')\r\n plt.close()\r" }, { "identifier": "save_imgs_explainable", "path": "utils.py", "snippet": "def save_imgs_explainable(ig,img,ig2,ig3,ig4,ig5, i,a, save_path, datasets, threshold=0.5, test_data_name=None):\r\n ig = ig.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n ig = ig / 255. if ig.max() > 1.1 else ig\r\n\r\n img = img.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n img = img / 255. if img.max() > 1.1 else img\r\n\r\n ig2 = ig2.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n ig2 = ig2 / 255. if ig2.max() > 1.1 else ig2\r\n\r\n ig3 = ig3.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n ig3 = ig3 / 255. if ig3.max() > 1.1 else ig3\r\n\r\n ig4 = ig4.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n ig4 = ig4 / 255. if ig4.max() > 1.1 else ig4\r\n\r\n ig5 = ig5.squeeze(0).permute(1,2,0).detach().cpu().numpy()\r\n ig5 = ig5 / 255. if ig5.max() > 1.1 else ig5\r\n\r\n images=[]\r\n\r\n plt.figure(figsize=(7,15))\r\n\r\n plt.subplot(6,1,1)\r\n plt.imshow(ig)\r\n plt.axis('off')\r\n\r\n plt.subplot(6,1,2)\r\n plt.imshow(img[:, :, 0], extent=[0, 32, 0, 32])\r\n plt.axis('off')\r\n images.append(img)\r\n\r\n plt.subplot(6,1,3)\r\n plt.imshow(ig2[:, :, 0], extent=[0, 32, 0, 32])\r\n plt.axis('off')\r\n images.append(ig2)\r\n\r\n plt.subplot(6,1,4)\r\n plt.imshow(ig3[:, :, 0], extent=[0, 32, 0, 32])\r\n plt.axis('off')\r\n images.append(ig3)\r\n\r\n plt.subplot(6,1,5)\r\n plt.imshow(ig4[:, :, 0], extent=[0, 32, 0, 32])\r\n plt.axis('off')\r\n images.append(ig4)\r\n\r\n plt.subplot(6,1,6)\r\n plt.imshow(ig5[:, :, 0], extent=[0, 32, 0, 32])\r\n plt.axis('off')\r\n images.append(ig5)\r\n\r\n # EICA\r\n \"\"\"\r\n Explainable Inference Classification Algorithm\r\n Created on Wed Nov 15 14:23:43 2023\r\n @author: Renkai Wu\r\n \"\"\"\r\n img_gray = (img[:, :, 0] * 255).astype(np.uint8)\r\n ig2_gray = (ig2[:, :, 0] * 255).astype(np.uint8)\r\n ig3_gray = (ig2[:, :, 0] * 255).astype(np.uint8)\r\n ig4_gray = (ig4[:, :, 0] * 255).astype(np.uint8)\r\n ig5_gray = (ig5[:, :, 0] * 255).astype(np.uint8)\r\n\r\n center_x, center_y = img.shape[1] // 2, img.shape[0] // 2\r\n\r\n # img\r\n quadrant_1 = img_gray[:center_y, center_x:]\r\n quadrant_2 = img_gray[:center_y, :center_x]\r\n quadrant_3 = img_gray[center_y:, :center_x]\r\n quadrant_4 = img_gray[center_y:, center_x:]\r\n\r\n # ig2\r\n ig2quadrant_1 = ig2_gray[:center_y, center_x:]\r\n ig2quadrant_2 = ig2_gray[:center_y, :center_x]\r\n ig2quadrant_3 = ig2_gray[center_y:, :center_x]\r\n ig2quadrant_4 = ig2_gray[center_y:, center_x:]\r\n\r\n # ig3\r\n ig3quadrant_1 = ig4_gray[:center_y, center_x:]\r\n ig3quadrant_2 = ig4_gray[:center_y, :center_x]\r\n ig3quadrant_3 = ig4_gray[center_y:, :center_x]\r\n ig3quadrant_4 = ig4_gray[center_y:, center_x:]\r\n\r\n # ig4\r\n ig4quadrant_1 = ig5_gray[:center_y, center_x:]\r\n ig4quadrant_2 = ig5_gray[:center_y, :center_x]\r\n ig4quadrant_3 = ig5_gray[center_y:, :center_x]\r\n ig4quadrant_4 = ig5_gray[center_y:, center_x:]\r\n\r\n # ig5\r\n ig6quadrant_1 = ig3_gray[:center_y, center_x:]\r\n ig6quadrant_2 = ig3_gray[:center_y, :center_x]\r\n ig6quadrant_3 = ig3_gray[center_y:, :center_x]\r\n ig6quadrant_4 = ig3_gray[center_y:, center_x:]\r\n\r\n threshold = 225\r\n\r\n condition_1 = np.max(quadrant_1) > threshold or np.max(quadrant_2) > threshold\r\n condition_2 = np.max(ig2quadrant_4) > threshold\r\n condition_3 = np.max(ig3quadrant_1) > threshold\r\n condition_4 = np.max(ig4quadrant_2) > threshold or np.max(ig4quadrant_3) > threshold\r\n\r\n conditions_met = sum([condition_1, condition_2, condition_3, condition_4])\r\n\r\n output = 1 if conditions_met >= 4 else 0\r\n print(output)\r\n s = a + output\r\n\r\n\r\n if test_data_name is not None:\r\n save_path = save_path + test_data_name + '_'\r\n plt.savefig(save_path + str(i) +'.png')\r\n plt.close()\r\n\r\n return s\r" } ]

[ { "identifier": "IMAGE_TOKEN_INDEX", "path": "model/utils.py", "snippet": "IMAGE_TOKEN_INDEX = -200" }, { "identifier": "DEFAULT_IMAGE_TOKEN", "path": "model/utils.py", "snippet": "DEFAULT_IMAGE_TOKEN = \"<image>\"" }, { "identifier": "DEFAULT_IM_START_TOKEN", "path": "model/utils.py", "snippet": "DEFAULT_IM_START_TOKEN = \"<im_start>\"" }, { "identifier": "DEFAULT_IM_END_TOKEN", "path": "model/utils.py", "snippet": "DEFAULT_IM_END_TOKEN = \"<im_end>\"" }, { "identifier": "build_conversation", "path": "model/utils.py", "snippet": "def build_conversation():\n conversation = Conversation(\n system=\n \"A chat between a curious human and an artificial intelligence assistant. \"\n \"The assistant gives helpful, detailed, and polite answers to the human's questions.\",\n roles=[\"USER\", \"ASSISTANT\"],\n version=\"TWO\",\n messages=[],\n offset=0,\n sep_style=SeparatorStyle.TWO,\n sep=\" \",\n sep2=\"</s>\",\n )\n return conversation" }, { "identifier": "load_pretrained_model", "path": "model/utils.py", "snippet": "def load_pretrained_model(model_path,\n load_8bit=False,\n load_4bit=False,\n device_map=\"auto\",\n device=\"cuda\"):\n kwargs = {\"device_map\": device_map}\n\n if load_8bit:\n kwargs['load_in_8bit'] = True\n elif load_4bit:\n kwargs['load_in_4bit'] = True\n kwargs['quantization_config'] = BitsAndBytesConfig(\n load_in_4bit=True,\n bnb_4bit_compute_dtype=torch.float16,\n bnb_4bit_use_double_quant=True,\n bnb_4bit_quant_type='nf4')\n else:\n kwargs['torch_dtype'] = torch.float16\n\n tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=False)\n model, output_loading_info = AutoModelForCausalLM.from_pretrained(\n model_path, output_loading_info=True, **kwargs)\n model.resize_token_embeddings(len(tokenizer))\n image_processor = model.model.image_processor\n\n if hasattr(model.config, \"max_sequence_length\"):\n context_len = model.config.max_sequence_length\n else:\n context_len = 2048\n\n return tokenizer, model, image_processor, context_len" }, { "identifier": "disable_torch_init", "path": "model/utils.py", "snippet": "def disable_torch_init():\n \"\"\"\n Disable the redundant torch default initialization to accelerate model creation.\n \"\"\"\n import torch\n setattr(torch.nn.Linear, \"reset_parameters\", lambda self: None)\n setattr(torch.nn.LayerNorm, \"reset_parameters\", lambda self: None)" }, { "identifier": "get_model_name_from_path", "path": "model/utils.py", "snippet": "def get_model_name_from_path(model_path):\n model_path = model_path.strip(\"/\")\n model_paths = model_path.split(\"/\")\n if model_paths[-1].startswith('checkpoint-'):\n return model_paths[-2] + \"_\" + model_paths[-1]\n else:\n return model_paths[-1]" }, { "identifier": "tokenizer_image_token", "path": "model/utils.py", "snippet": "def tokenizer_image_token(prompt,\n tokenizer,\n image_token_index=IMAGE_TOKEN_INDEX,\n return_tensors=None):\n prompt_chunks = [\n tokenizer(chunk).input_ids for chunk in prompt.split('<image>')\n ]\n\n def insert_separator(X, sep):\n return [ele for sublist in zip(X, [sep] * len(X))\n for ele in sublist][:-1]\n\n input_ids = []\n offset = 0\n if len(prompt_chunks) > 0 and len(\n prompt_chunks[0]\n ) > 0 and prompt_chunks[0][0] == tokenizer.bos_token_id:\n offset = 1\n input_ids.append(prompt_chunks[0][0])\n\n for x in insert_separator(prompt_chunks,\n [image_token_index] * (offset + 1)):\n input_ids.extend(x[offset:])\n\n if return_tensors is not None:\n if return_tensors == 'pt':\n return torch.tensor(input_ids, dtype=torch.long)\n raise ValueError(f'Unsupported tensor type: {return_tensors}')\n return input_ids" }, { "identifier": "process_images", "path": "model/utils.py", "snippet": "def process_images(images, image_processor, model_cfg):\n new_images = []\n for image in images:\n image = expand2square(\n image, tuple(int(x * 255) for x in image_processor.image_mean))\n image = image_processor.preprocess(\n image, return_tensors='pt')['pixel_values'][0]\n new_images.append(image)\n if all(x.shape == new_images[0].shape for x in new_images):\n new_images = torch.stack(new_images, dim=0)\n return new_images" } ]

[ { "identifier": "generate_splits", "path": "data/dataset.py", "snippet": "def generate_splits(dataset, splits: Tuple[float, float]):\n length = len(dataset)\n split_size = int(splits[0] * length)\n\n return torch.utils.data.Subset(dataset, range(split_size)), torch.utils.data.Subset(\n dataset, range(split_size, length)\n )" }, { "identifier": "get_dataloader", "path": "data/dataset.py", "snippet": "def get_dataloader(dataset, **dataloader_kwargs):\n collator = DataCollator(pad_token_id=0, shift_labels=False)\n return torch.utils.data.DataLoader(dataset, collate_fn=collator, **dataloader_kwargs)" }, { "identifier": "get_dataset", "path": "data/dataset.py", "snippet": "def get_dataset(\n dataset_root: str = \"tokenized_dataset\",\n min_sequence_length=128,\n max_sequence_length=1024,\n subset: float = 1.0,\n):\n files = list(Path(dataset_root).glob(\"**/*.json\"))\n files = files[: int(len(files) * subset)]\n ds = DatasetTok(\n files,\n min_seq_len=min_sequence_length,\n max_seq_len=max_sequence_length,\n one_token_stream=False,\n )\n return ds" }, { "identifier": "TchAIkovskyModel", "path": "model/model.py", "snippet": "class TchAIkovskyModel(eqx.Module):\n id_embeddings: eqx.Module\n pos_embeddings: eqx.Module\n decoder: eqx.Module\n norm_out: eqx.Module\n out_head: eqx.Module\n\n dtype: jnp.dtype = eqx.field(static=True)\n output_dtype: jnp.dtype = eqx.field(static=True)\n\n def __init__(\n self,\n dim: int,\n num_heads: int,\n num_layers: int,\n vocab_size: int,\n max_positions: int,\n head_dim: Optional[int] = None,\n dropout: float = 0.0,\n key: PRNGKey = None,\n dtype: jnp.dtype = jnp.float32,\n output_dtype: jnp.dtype = jnp.float32,\n ):\n self.dtype = dtype\n self.output_dtype = output_dtype\n id_embeddings_key, pos_embeddings_key, decoder_key, out_key = jax.random.split(key, 4)\n\n self.id_embeddings = eqx.nn.Embedding(vocab_size, dim, key=id_embeddings_key)\n self.pos_embeddings = eqx.nn.Embedding(max_positions, dim, key=pos_embeddings_key)\n\n self.decoder = Decoder(\n decoder_key,\n dim,\n num_heads,\n num_layers,\n head_dim=head_dim,\n dropout=dropout,\n dtype=dtype,\n )\n\n self.norm_out = eqx.nn.LayerNorm(dim)\n self.out_head = eqx.nn.Linear(dim, vocab_size, use_bias=True, key=out_key)\n\n def __call__(self, input_ids, position_ids, mask, key=None):\n causal_mask = make_causal_mask(input_ids)[0]\n mask = jnp.where(mask, causal_mask, 0)\n\n x = jax.vmap(self.id_embeddings)(input_ids) + jax.vmap(self.pos_embeddings)(position_ids)\n x = self.decoder(x, mask, key)\n\n x = jax.vmap(self.norm_out)(x)\n logits = jax.vmap(self.out_head)(x)\n logits = logits.astype(self.output_dtype)\n return logits" }, { "identifier": "seed_others", "path": "utils.py", "snippet": "def seed_others(seed):\n torch.manual_seed(seed)\n np.random.seed(seed)\n random.seed(seed)" } ]

[ { "identifier": "color_similarity", "path": "aoc_tiles/colors.py", "snippet": "def color_similarity(color_a, color_b, threshold):\n return abs(luminance(color_a) - luminance(color_b)) < threshold" }, { "identifier": "darker_color", "path": "aoc_tiles/colors.py", "snippet": "def darker_color(c: Tuple[int, int, int, int]) -> Tuple[int, int, int, int]:\n return c[0] - 10, c[1] - 10, c[2] - 10, 255" }, { "identifier": "extension_to_colors", "path": "aoc_tiles/colors.py", "snippet": "@lru_cache\ndef extension_to_colors() -> Dict[str, str]:\n extension_to_color = {}\n with open(GITHUB_LANGUAGES_PATH) as file:\n logger.debug(\"Loading github_languages.yaml from {}\", GITHUB_LANGUAGES_PATH)\n yaml_loader = yaml.CLoader if yaml.__with_libyaml__ else yaml.Loader\n if not yaml.__with_libyaml__:\n logger.warning(\"Using slow yaml parser (0.5s vs 0.1s)!\")\n github_languages = yaml.load(file, Loader=yaml_loader)\n logger.debug(\"Loaded github_languages.yaml from {}\", GITHUB_LANGUAGES_PATH)\n for language, data in github_languages.items():\n if \"color\" in data and \"extensions\" in data and data[\"type\"] == \"programming\" and language not in excludes:\n for extension in data[\"extensions\"]:\n extension_to_color[extension.lower()] = data[\"color\"]\n\n extension_to_color.update(includes)\n\n return extension_to_color" }, { "identifier": "Config", "path": "aoc_tiles/config.py", "snippet": "class Config:\n aoc_dir: Union[str, Path] = field(default=\"./\", metadata={\"help\": \"Path to the AoC directory.\", \"type\": str})\n readme_path: Union[str, Path] = field(init=False)\n session_cookie_path: Union[str, Path] = field(init=False)\n aoc_tiles_dir: Union[str, Path] = field(init=False)\n image_dir: Union[str, Path] = field(init=False)\n cache_dir: Union[str, Path] = field(init=False)\n\n verbose: bool = field(default=False, metadata={\"help\": \"Whether to print debug information.\"})\n\n what_to_show_on_right_side: Literal[\"auto\", \"checkmark\", \"time_and_rank\", \"loc\"] = field(\n default=\"auto\", metadata={\n \"help\": \"What information to display on the right side of each tile. \"\n \"'checkmark' only displays a checkmark for each part if the day is solved. \"\n \"'time_and_rank' displays the time and rank on the global leaderboard (requires session.cookie). \"\n \"'loc' displays the number of lines of code of the solution (not implemented). \"\n \"'auto' will use 'time_and_rank' if session.cookie exists, otherwise 'checkmark'.\"}\n )\n count_as_solved_when: Literal[\"auto\", \"on_leaderboard\", \"file_exists\", \"either\", \"both\"] = field(\n default=\"auto\",\n metadata={\n \"help\": \"Condition to count a task as solved. Note that 'on_leaderboard', 'either' and 'both' require a \"\n \"session cookie. 'auto' will use 'both' if session.cookie exists, otherwise 'file_exists'.\"\n },\n )\n language_sorting: List[str] = field(\n default_factory=list,\n metadata={\n \"help\": \"Preferred language extensions order for sorting. For example 'py,rs,js' will make Python \"\n \"solutions appear first, then Rust, then JavaScript, then everything else (alphabetically).\"\n },\n )\n create_all_days: bool = field(default=False, metadata={\"help\": \"Whether to create entries for all days upfront.\"})\n\n auto_add_tiles_to_git: Literal[\"no\", \"add\", \"amend\"] = field(default=\"no\", metadata={\n \"help\": \"Whether to automatically add the tile images to git. 'add' will add new files, 'amend' will add \"\n \"and amend the commit with the new files. 'no' will not add the files to git.\"})\n only_use_solutions_in_git: bool = field(default=True, metadata={\n \"help\": \"If true, only solutions will be considered which are tracked by git (git added), \"\n \"otherwise all solutions will be used. This is useful for example to ignore auto-generated\"\n \"files, like '.d' in Rust or '.o' files in C++.\"})\n\n show_total_stars_for_all_years: Literal[\"no\", \"auto\", \"yes\"] = field(default=\"auto\", metadata={\n \"help\": \"Whether to add an additional header in front which shows the total collected stars for all years.\"\n \"'auto' will only show the header if you have stars in at least 3 separate years. \"\n \"'yes' will always show the header. 'no' will never show the header.\"})\n\n year_pattern: str = field(\n default=r\"(?<!\\d)(20[123]\\d)(?!\\d)\",\n metadata={\n \"help\": \"Regex pattern for matching years. This extracts the first group as the year and parses it as an \"\n \"integer. Make sure that other numbers are not matched by this pattern! For example, \"\n \"using negative lookbehind and lookaheads is encouraged to avoid matching longer numbers!\"\n },\n )\n day_pattern: str = field(\n default=r\"(?<!\\d)([012]?\\d)(?!\\d)\", metadata={\"help\": \"Regex pattern for matching days. Same as year_pattern.\"}\n )\n exclude_patterns: List[str] = field(\n default_factory=list, metadata={\n \"help\": \"A list of comma separated glob patterns to ignore when looking for solutions. \"\n \"Listing the paths works too. \"\n \"For example: '*.py,*.js', '2023/05/05.c' or '2021/**.py'.\"\n \"Make sure to escape the patterns with single quotes when running from the shell! \"\n \"Do NOT escape them when using the flag in the yaml! \"\n \"Otherwise the qoute will be part of the pattern.\"\n }\n )\n\n overwrite_year: int = field(\n default=None,\n metadata={\n \"help\": \"If your repository only contains a single year and it cannot be parsed from the path, then you \"\n \"should use this to overwrite the year. Every solution is presumed to be for this year.\"\n },\n )\n\n contrast_improvement_type: Literal[\"none\", \"outline\", \"dark\"] = field(\n default=\"outline\",\n metadata={\n \"help\": \"Some languages have very light colors and are hard to see with a white font. Here you can choose \"\n \"how the text color changes when the background is too light. 'dark' makes the font dark, \"\n \"'outline' adds a black outline.\"\n },\n )\n contrast_improvement_threshold: int = field(\n default=30, metadata={\"help\": \"Threshold for contrast improvement feature (between 0 and 255).\"}\n )\n outline_color: Union[str, Tuple] = field(\n default=\"#6C6A6A\", metadata={\"help\": \"Color used for outlining elements.\", \"type\": str}\n )\n not_completed_color: Union[str, Tuple] = field(\n default=\"#333333\", metadata={\"help\": \"Color to signify incomplete tasks.\", \"type\": str}\n )\n top100_color: Union[str, Tuple] = field(\n default=\"#ffdd00\", metadata={\"help\": \"Color to highlight top 100 ranking. Only used if session\"\n \"cookie is provided.\", \"type\": str}\n )\n text_color: Union[str, Tuple] = field(default=\"#FFFFFF\", metadata={\"help\": \"Text color.\", \"type\": str})\n\n tile_width_px: str = field(default=\"161px\", metadata={\"help\": \"Width of tiles in pixels. You likely don't need\"\n \"to change this.\"})\n\n def __post_init__(self):\n self.aoc_dir = Path(self.aoc_dir)\n\n if not hasattr(self, \"readme_path\"):\n readmes = [path for path in self.aoc_dir.iterdir() if path.name.lower() == \"readme.md\"]\n if len(readmes) == 0:\n exit(f\"[ERROR] No README.md found in the root directory of the repository '{self.aoc_dir}'.\")\n elif len(readmes) > 1:\n exit(f\"[ERROR] Multiple README.md files found in the root directory of the repository {readmes}.\")\n self.readme_path = readmes[0]\n\n if not hasattr(self, \"aoc_tiles_dir\"):\n self.aoc_tiles_dir = self.aoc_dir / \".aoc_tiles\"\n self.aoc_tiles_dir.mkdir(exist_ok=True)\n\n self.running_lock_path = self.aoc_tiles_dir / \"running.lock\"\n\n if not hasattr(self, \"session_cookie_path\"):\n self.session_cookie_path = self.aoc_tiles_dir / \"session.cookie\"\n if not self.session_cookie_path.exists():\n self.session_cookie_path = self.aoc_dir / \"session.cookie\"\n\n if not hasattr(self, \"image_dir\"):\n self.image_dir = self.aoc_tiles_dir / \"tiles\"\n\n if not hasattr(self, \"cache_dir\"):\n self.cache_dir = self.aoc_tiles_dir / \"cache\"\n\n if self.count_as_solved_when == \"auto\":\n self.count_as_solved_when = \"both\" if self.session_cookie_path.exists() else \"file_exists\"\n\n if self.what_to_show_on_right_side == \"auto\":\n self.what_to_show_on_right_side = \"time_and_rank\" if self.session_cookie_path.exists() else \"checkmark\"\n\n self.outline_color = ImageColor.getrgb(self.outline_color)\n self.not_completed_color = ImageColor.getrgb(self.not_completed_color)\n self.text_color = ImageColor.getrgb(self.text_color)\n self.top100_color = ImageColor.getrgb(self.top100_color)\n\n for i, suffix in enumerate(self.language_sorting):\n if not suffix.startswith(\".\"):\n self.language_sorting[i] = \".\" + suffix\n\n logger.remove()\n if self.verbose:\n logger.add(sys.stderr, level=\"DEBUG\")\n\n logger.debug(self)" }, { "identifier": "main_font", "path": "aoc_tiles/fonts.py", "snippet": "def main_font(size: int) -> ImageFont:\n return get_font(size, FONTS_PATH / \"PaytoneOne.ttf\")" }, { "identifier": "secondary_font", "path": "aoc_tiles/fonts.py", "snippet": "def secondary_font(size: int) -> ImageFont:\n return get_font(size, FONTS_PATH / \"SourceCodePro-Regular.otf\")" }, { "identifier": "DayScores", "path": "aoc_tiles/leaderboard.py", "snippet": "class DayScores:\n time1: Union[str, None] = None\n rank1: Union[str, None] = None\n score1: Union[str, None] = None\n time2: Union[str, None] = None\n rank2: Union[str, None] = None\n score2: Union[str, None] = None" } ]

[ { "identifier": "GBSWT5Config", "path": "gbswt5/configuration_gbst5.py", "snippet": "class GBSWT5Config(PretrainedConfig):\n \"\"\" Based on models.t5. configuration_t5. T5Config in hf Transformers. \"\"\"\n model_type = \"gbswt5\"\n keys_to_ignore_at_inference = [\"past_key_values\"]\n attribute_map = {\"hidden_size\": \"d_model\",\n \"num_attention_heads\": \"num_heads\",\n \"num_hidden_layers\": \"num_layers\"}\n\n def __init__(\n self,\n vocab_size=384,\n d_model=512,\n d_kv=64,\n d_ff=2048,\n num_layers=6,\n num_decoder_layers=None,\n num_heads=8,\n relative_attention_num_buckets=32,\n relative_attention_max_distance=128,\n dropout_rate=0.1,\n layer_norm_epsilon=1e-6,\n initializer_factor=1.0,\n feed_forward_proj=\"relu\",\n is_encoder_decoder=True,\n use_cache=True,\n pad_token_id=0,\n eos_token_id=1,\n max_subword_block_size=None, # GBSWT-related options here from\n subword_blocks=_BLOCKS,\n downsample_factor=1,\n score_consensus_attn=True,\n z_loss=1e-4,\n gbst_batchnorm=False,\n **kwargs,\n ):\n self.vocab_size = vocab_size\n self.d_model = d_model\n self.d_kv = d_kv\n self.d_ff = d_ff\n self.num_layers = num_layers\n self.num_decoder_layers = (\n num_decoder_layers if num_decoder_layers is not None else self.num_layers\n ) # default = symmetry\n self.num_heads = num_heads\n self.relative_attention_num_buckets = relative_attention_num_buckets\n self.relative_attention_max_distance = relative_attention_max_distance\n self.dropout_rate = dropout_rate\n self.layer_norm_epsilon = layer_norm_epsilon\n self.initializer_factor = initializer_factor\n self.feed_forward_proj = feed_forward_proj\n self.use_cache = use_cache\n\n act_info = self.feed_forward_proj.split(\"-\")\n self.dense_act_fn = act_info[-1]\n self.is_gated_act = act_info[0] == \"gated\"\n\n # GBSWT-related configurations\n self.max_subword_block_size = max_subword_block_size\n self.subword_blocks = subword_blocks\n self.downsample_factor = downsample_factor\n self.score_consensus_attn = score_consensus_attn\n self.gbst_batchnorm = gbst_batchnorm\n\n # z_loss for computational stability.\n # see https://github.com/tensorflow/mesh/blob \\\n # /fa19d69eafc9a482aff0b59ddd96b025c0cb207d/mesh_tensorflow/layers.py#L666\n # (1) logits이 0으로 부터 너무 멀어지게 드리프팅 되지 않도록 하여, bf16에서 발생하는\n # round-off error를 방지하기 위함. (2) 로짓이 normalized log-probabilities가 되도록 제고한다.\n self.z_loss = z_loss\n\n if self.subword_blocks is not None and isinstance(self.subword_blocks, list):\n for idx, elem in enumerate(self.subword_blocks):\n self.subword_blocks[idx] = tuple(elem)\n self.subword_blocks = tuple(self.subword_blocks)\n\n if len(act_info) > 1 and act_info[0] != \"gated\" or len(act_info) > 2:\n raise ValueError(\n f\"`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.\"\n \"Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. \"\n \"'gated-gelu' or 'relu'\"\n )\n\n # for backwards compatibility\n if feed_forward_proj == \"gated-gelu\":\n self.dense_act_fn = \"gelu_new\"\n\n super().__init__(\n pad_token_id=pad_token_id,\n eos_token_id=eos_token_id,\n is_encoder_decoder=is_encoder_decoder,\n **kwargs,\n )" }, { "identifier": "GBSWT", "path": "gbswt5/gbst.py", "snippet": "class GBSWT(nn.Module):\n \"\"\" Gradient-based Sub-Word Tokenizer implementation. \"\"\"\n def __init__(self, embed_tokens,\n max_block_size=None,\n blocks=_BLOCKS,\n downsample_factor=1,\n score_consensus_attn=True,\n use_bn=False,):\n super().__init__()\n num_tokens, dim = embed_tokens.weight.shape\n\n assert (max_block_size is not None) ^ (blocks is not None), \\\n 'max_block_size or blocks must be given.'\n if blocks is None:\n self.blocks = tuple(map(lambda elem: (elem, 0), range(1, max_block_size+1)))\n else:\n if not isinstance(blocks, tuple):\n raise ValueError('blocks must be assigned as a tuple')\n self.blocks = tuple(map(lambda elem: elem if isinstance(elem, tuple) else (elem, 0), blocks))\n if not all([(offset < block_size) for block_size, offset in self.blocks]):\n raise ValueError('Offset must be smaller than given block size.')\n max_block_size = max(list(map(lambda x: x[0], self.blocks)))\n\n assert downsample_factor <= max_block_size, \\\n 'downsample factor must be less than the max_block_size.'\n\n self.downsample_factor = downsample_factor\n self.score_consensus_attn = score_consensus_attn\n self.use_bn = use_bn\n logger.debug(f\"GBSWT Subword Block Combinations: {self.blocks}\")\n logger.debug(f\"GBSWT Downsampling factor: {self.downsample_factor}, use BatchNorm: {self.use_bn}\")\n\n def lcm(*num):\n return int(functools.reduce(lambda x, y: int((x * y) / math.gcd(x, y)), num, 1))\n\n self.block_pad_multiple = lcm(*[block_size for block_size, _ in self.blocks])\n #print(f\"block_pad_multiple: {self.block_pad_multiple}\")\n\n # layer definition\n self.embeds = embed_tokens\n self.positional_convol = nn.Sequential(\n Padding((0, 0, 0, max_block_size-1)),\n Rearrange('b s d -> b d s'),\n Depthwise1dConv(dim, dim, krnl_size=max_block_size, use_bn=self.use_bn,),\n Rearrange('b d s -> b s d'))\n self.cand_scoring = nn.Sequential(\n nn.Linear(dim, 1),\n Rearrange('... () -> ...'))\n\n def _init_weights(self, factor:float=0.05):\n self.positional_convol[2]._init_weights(factor)\n #print(f\"GBSTW weight initialization called: before: {self.cand_scoring[0].weight.data}\")\n self.cand_scoring[0].weight.data.normal_(mean=0.0, std=factor * 1.0)\n #print(f\"GBSTW weight initialization called: after: {self.cand_scoring[0].weight.data}\")\n\n def get_blocks(self):\n \"\"\" return GBST candidate blocking list. \"\"\"\n return self.blocks\n\n @torch.cuda.amp.autocast()\n def forward(self, in_tensor, attention_mask=None):\n b, s = in_tensor.shape\n #print(f\"initial shape: b, s : {b}, {s}, in_tensor.shape: {in_tensor.shape}\")\n mask = attention_mask\n #print(f\"mask: {mask}\")\n block_multi, ds_factor = self.block_pad_multiple, self.downsample_factor\n\n in_tensor = self.embeds(in_tensor)\n in_tensor = self.positional_convol(in_tensor)\n in_tensor = pad_to_multiple(in_tensor, block_multi,\n seq_dim=1, dim=-2, value=0.0)\n if mask is not None:\n mask = pad_to_multiple(mask, block_multi,\n seq_dim=1, dim=-1, value=False)\n\n def _masked_mean(in_tensor:Tensor, mask:Tensor, dim:int=-1):\n len_diff = len(in_tensor.shape) - len(mask.shape)\n mask = torch.unsqueeze(mask, dim=-len_diff)\n in_tensor.masked_fill_(~(mask.bool()), 0.)\n\n total_elems = mask.sum(dim=dim)\n mean = in_tensor.sum(dim=dim) / total_elems.clamp(min=1.)\n mean.masked_fill_((total_elems == 0), 0.)\n return mean.float()\n\n block_reprs, block_masks = [], []\n\n # 이제 입력 시퀀스를 cloning해서 후보를 세팅\n for block_size, offset in self.blocks:\n block_in = in_tensor.clone()\n if mask is not None:\n block_mask = mask.clone()\n need_padding = offset > 0\n\n if need_padding:\n loff, roff = (block_size - offset), offset\n #print(f\"loff: {loff}, roff: {roff}\")\n block_in = F.pad(block_in, (0, 0, loff, roff), value=0.0)\n if mask is not None:\n block_mask = F.pad(block_mask, (0, 0, loff, roff), value=False)\n\n blks = rearrange(block_in, 'b (s m) d -> b s m d', m=block_size)\n if mask is not None:\n mask_blks = rearrange(block_mask, 'b (s m) -> b s m', m=block_size)\n blk_repr = _masked_mean(blks, mask_blks, dim=-2)\n else:\n blk_repr = blks.mean(dim=-2)\n\n blk_repr = repeat(blk_repr, 'b s d -> b (s m) d', m=block_size)\n\n if need_padding:\n blk_repr = blk_repr[:, loff:-roff]\n\n block_reprs.append(blk_repr)\n\n if mask is not None:\n mask_blks = torch.any(mask_blks, dim=-1)\n mask_blks = repeat(mask_blks, 'b s -> b (s m)', m=block_size)\n if need_padding:\n mask_blks = mask_blks[:, loff:-roff]\n block_masks.append(mask_blks)\n\n # stack them all\n block_reprs = torch.stack(block_reprs, dim=2,)\n scores = self.cand_scoring(block_reprs)\n\n if mask is not None:\n block_masks = torch.stack(block_masks, dim=2)\n max_neg_val = -torch.finfo(scores.dtype).max\n scores = scores.masked_fill(~block_masks, max_neg_val)\n\n scores = scores.softmax(dim=2)\n\n # cheap consensus attention, as equation (5) in paper.\n if self.score_consensus_attn:\n score_sim = einsum('b i d, b j d -> b i j', scores, scores)\n\n if mask is not None:\n cross_mask = rearrange(mask, 'b i -> b i ()') * rearrange(mask, 'b j -> b () j')\n max_neg_val = -torch.finfo(score_sim.dtype).max\n score_sim = score_sim.masked_fill((~(cross_mask.bool())), max_neg_val)\n\n score_attn = score_sim.softmax(dim=-1)\n scores = einsum('b i j, b j m -> b i m', score_attn, scores)\n\n scores = rearrange(scores, 'b n m -> b n m ()')\n in_tensor = (block_reprs * scores).sum(dim=2)\n\n @torch.jit.script\n def _reshape_input_tensor(in_tensor:Tensor, s:int, d:int):\n # get divisible length to pad\n m = int(math.ceil(s / d) * d)\n #print(f\"_reshape_input_tensor: {m}\")\n return in_tensor[:, :m]\n\n in_tensor = _reshape_input_tensor(in_tensor, s, ds_factor)\n if mask is not None:\n mask = _reshape_input_tensor(mask, s, ds_factor)\n\n # downsample with mean pooling\n in_tensor = rearrange(in_tensor, 'b (n m) d -> b n m d', m=ds_factor)\n if mask is not None:\n mask = rearrange(mask, 'b (n m) -> b n m', m=ds_factor)\n in_tensor = _masked_mean(in_tensor, mask, dim=2)\n mask = torch.any(mask, dim=-1)\n else:\n in_tensor = in_tensor.mean(dim=-2)\n\n # tuple을 반환하기 때문에, forward()에서 [0]을 취해 바꿔줘야 한다\n return in_tensor, mask" } ]

[ { "identifier": "utils", "path": "goat_storytelling_agent/utils.py", "snippet": "def split_into_words_w_newline(text):\ndef remove_last_n_words(text, n):\ndef keep_last_n_words(text, n):" }, { "identifier": "Plan", "path": "goat_storytelling_agent/plan.py", "snippet": "class Plan:\n @staticmethod\n def split_by_act(original_plan):\n # removes only Act texts with newline prepended soemwhere near\n acts = re.split('\\n.{0,5}?Act ', original_plan)\n # remove random short garbage from re split\n acts = [text.strip() for text in acts[:]\n if (text and (len(text.split()) > 3))]\n if len(acts) == 4:\n acts = acts[1:]\n elif len(acts) != 3:\n print('Fail: split_by_act, attempt 1', original_plan)\n acts = original_plan.split('Act ')\n if len(acts) == 4:\n acts = acts[-3:]\n elif len(acts) != 3:\n print('Fail: split_by_act, attempt 2', original_plan)\n return []\n\n # [act1, act2, act3], [Act + act1, act2, act3]\n if acts[0].startswith('Act '):\n acts = [acts[0]] + ['Act ' + act for act in acts[1:]]\n else:\n acts = ['Act ' + act for act in acts[:]]\n return acts\n\n @staticmethod\n def parse_act(act):\n act = re.split(r'\\n.{0,20}?Chapter .+:', act.strip())\n chapters = [text.strip() for text in act[1:]\n if (text and (len(text.split()) > 3))]\n return {'act_descr': act[0].strip(), 'chapters': chapters}\n\n @staticmethod\n def parse_text_plan(text_plan):\n acts = Plan.split_by_act(text_plan)\n if not acts:\n return []\n plan = [Plan.parse_act(act) for act in acts if act]\n plan = [act for act in plan if act['chapters']]\n return plan\n\n @staticmethod\n def normalize_text_plan(text_plan):\n plan = Plan.parse_text_plan(text_plan)\n text_plan = Plan.plan_2_str(plan)\n return text_plan\n\n @staticmethod\n def act_2_str(plan, act_num):\n text_plan = ''\n chs = []\n ch_num = 1\n for i, act in enumerate(plan):\n act_descr = act['act_descr'] + '\\n'\n if not re.search(r'Act \\d', act_descr[0:50]):\n act_descr = f'Act {i+1}:\\n' + act_descr\n for chapter in act['chapters']:\n if (i + 1) == act_num:\n act_descr += f'- Chapter {ch_num}: {chapter}\\n'\n chs.append(ch_num)\n elif (i + 1) > act_num:\n return text_plan.strip(), chs\n ch_num += 1\n text_plan += act_descr + '\\n'\n return text_plan.strip(), chs\n\n @staticmethod\n def plan_2_str(plan):\n text_plan = ''\n ch_num = 1\n for i, act in enumerate(plan):\n act_descr = act['act_descr'] + '\\n'\n if not re.search(r'Act \\d', act_descr[0:50]):\n act_descr = f'Act {i+1}:\\n' + act_descr\n for chapter in act['chapters']:\n act_descr += f'- Chapter {ch_num}: {chapter}\\n'\n ch_num += 1\n text_plan += act_descr + '\\n'\n return text_plan.strip()\n\n @staticmethod\n def save_plan(plan, fpath):\n with open(fpath, 'w') as fp:\n json.dump(plan, fp, indent=4)" } ]

[ { "identifier": "divide_and_conquer", "path": "modules/topk/polynomial/divide_conquer.py", "snippet": "def divide_and_conquer(x, k, mul):\n \"\"\"\n Divide and conquer method for polynomial expansion\n x is a 2d tensor of size (n_classes, n_roots)\n The objective is to obtain the k first coefficients of the expanded\n polynomial\n \"\"\"\n\n to_merge = []\n\n while x[0].dim() > 1 and x[0].size(0) > 1:\n size = x[0].size(0)\n half = size // 2\n if 2 * half < size:\n to_merge.append([t[-1] for t in x])\n x = mul([t[:half] for t in x],\n [t[half: 2 * half] for t in x])\n\n for row in to_merge:\n x = mul(x, row)\n x = torch.cat(x)\n return x" }, { "identifier": "Multiplication", "path": "modules/topk/polynomial/multiplication.py", "snippet": "def Multiplication(k):\n \"\"\"\n Generate a function that performs a polynomial multiplication and return coefficients up to degree k\n \"\"\"\n assert isinstance(k, int) and k > 0\n\n def isum(factors):\n init = next(factors)\n return reduce(operator.iadd, factors, init)\n\n def mul_function(x1, x2):\n\n # prepare indices for convolution\n l1, l2 = len(x1), len(x2)\n M = min(k + 1, l1 + l2 - 1)\n indices = [[] for _ in range(M)]\n for (i, j) in itertools.product(range(l1), range(l2)):\n if i + j >= M:\n continue\n indices[i + j].append((i, j))\n\n # wrap with log-tensors for stability\n X1 = [LogTensor(x1[i]) for i in range(l1)]\n X2 = [LogTensor(x2[i]) for i in range(l2)]\n\n # perform convolution\n coeff = []\n for c in range(M):\n coeff.append(isum(X1[i] * X2[j] for (i, j) in indices[c]).torch())\n return coeff\n\n return mul_function" }, { "identifier": "d_logS_d_expX", "path": "modules/topk/polynomial/grad.py", "snippet": "def d_logS_d_expX(S, X, j, p, grad, thresh, eps=1e-5):\n \"\"\"\n Compute the gradient of log S[j] w.r.t. exp(X).\n For unstable cases, use p-th order approximnation.\n \"\"\"\n\n # ------------------------------------------------------------------------\n # Detect unstabilites\n # ------------------------------------------------------------------------\n\n _X_ = LogTensor(X)\n _S_ = [LogTensor(S[i]) for i in range(S.size(0))]\n\n # recursion of gradient formula (separate terms for stability)\n _N_, _P_ = recursion(_S_, _X_, j)\n\n # deal with edge case where _N_ or _P_ is 0 instead of a LogTensor (happens for k=2):\n # fill with large negative values (numerically equivalent to 0 in log-space)\n if not isinstance(_N_, LogTensor):\n _N_ = LogTensor(-1.0 / eps * torch.ones_like(X))\n if not isinstance(_P_, LogTensor):\n _P_ = LogTensor(-1.0 / eps * torch.ones_like(X))\n\n P, N = _P_.torch(), _N_.torch()\n\n # detect instability: small relative difference in log-space\n diff = (P - N) / (N.abs() + eps)\n\n # split into stable and unstable indices\n u_indices = torch.lt(diff, thresh) # unstable\n s_indices = u_indices.eq(0) # stable\n\n # ------------------------------------------------------------------------\n # Compute d S[j] / d X\n # ------------------------------------------------------------------------\n\n # make grad match size and type of X\n grad = grad.type_as(X).resize_as_(X)\n\n # exact gradient for s_indices (stable) elements\n if s_indices.sum():\n # re-use positive and negative parts of recursion (separate for stability)\n _N_ = LogTensor(_N_.torch()[s_indices])\n _P_ = LogTensor(_P_.torch()[s_indices])\n _X_ = LogTensor(X[s_indices])\n _S_ = [LogTensor(S[i][s_indices]) for i in range(S.size(0))]\n\n # d log S[j] / d exp(X) = (d S[j] / d X) * X / S[j]\n _SG_ = (_P_ - _N_) * _X_ / _S_[j]\n grad.masked_scatter_(s_indices, _SG_.torch().exp())\n\n # approximate gradients for u_indices (unstable) elements\n if u_indices.sum():\n _X_ = LogTensor(X[u_indices])\n _S_ = [LogTensor(S[i][u_indices]) for i in range(S.size(0))]\n\n # positive and negative parts of approximation (separate for stability)\n _N_, _P_ = approximation(_S_, _X_, j, p)\n\n # d log S[j] / d exp(X) = (d S[j] / d X) * X / S[j]\n _UG_ = (_P_ - _N_) * _X_ / _S_[j]\n grad.masked_scatter_(u_indices, _UG_.torch().exp())\n\n return grad" } ]

[ { "identifier": "EmbedStatics", "path": "discord_service/embeds/embed_helper.py", "snippet": "class EmbedStatics:\n def __init__(self):\n pass\n\n def status_to_string(status):\n if status:\n return \"enabled\"\n else:\n return \"disabled\"\n\n @staticmethod\n def build_status_display_embed(status):\n embed = discord.Embed(\n title=\"Describer\",\n description=f\"The image descriptions status for this server is: `{EmbedStatics.status_to_string(status)}`\",\n color=discord.Color.blurple(),\n )\n embed.set_thumbnail(url=\"https://i.imgur.com/txHhNzL.png\")\n return embed\n\n @staticmethod\n def build_status_change_success_embed(status):\n embed = discord.Embed(\n title=\"Describer\",\n description=f\"Successfully changed image descriptions for this server to the status:\\n`{EmbedStatics.status_to_string(status)}`\",\n color=discord.Color.green(),\n )\n # thumbnail of https://i.imgur.com/I5dIdg6.png\n embed.set_thumbnail(url=\"https://i.imgur.com/I5dIdg6.png\")\n return embed\n\n @staticmethod\n def build_status_set_failure_embed(message):\n embed = discord.Embed(\n title=\"Describer\",\n description=f\"There was an error changing the image descriptions status for this server: \"\n + message,\n color=discord.Color.red(),\n )\n embed.set_thumbnail(url=\"https://i.imgur.com/hbdBZfG.png\")\n return embed\n\n @staticmethod\n def build_image_analysis_failure_embed(message):\n embed = discord.Embed(\n title=\"Describer\",\n description=f\"There was an error describing the image sent: \" + message,\n color=discord.Color.red(),\n )\n embed.set_thumbnail(url=\"https://i.imgur.com/hbdBZfG.png\")\n return embed\n\n @staticmethod\n def build_described_image_embed(\n message: discord.Message, image_url: str, description: str\n ):\n embed = discord.Embed(\n title=f\"{message.author.display_name} sent an image that was automatically described\",\n description=f\"{description}\",\n color=discord.Color.light_gray(),\n )\n embed.set_thumbnail(url=image_url)\n embed.set_author(\n name=message.author.display_name, icon_url=message.author.avatar.url\n )\n embed.set_footer(\n text=f\"Automatically described for an image sent by {message.author.display_name}\",\n icon_url=message.author.avatar.url,\n )\n return embed" }, { "identifier": "Check", "path": "services/check_service.py", "snippet": "class Check:\n @staticmethod\n def check_admin_roles() -> Callable:\n async def inner(ctx: discord.ApplicationContext):\n admin_roles = EnvService.get_admin_roles()\n if EnvService.get_admin_roles() == [None]:\n admin_roles = [\"admin\"]\n\n if not any(role.name.lower() in admin_roles for role in ctx.user.roles):\n await ctx.defer(ephemeral=True)\n await ctx.respond(\n f\"You don't have permission, list of roles is {admin_roles}\",\n ephemeral=True,\n delete_after=10,\n )\n return False\n return True\n\n return inner" }, { "identifier": "EnvService", "path": "services/environment_service.py", "snippet": "class EnvService:\n # To be expanded upon later!\n def __init__(self):\n self.env = {}\n\n @staticmethod\n def environment_path_with_fallback(env_name, relative_fallback=None):\n directory = os.getenv(env_name)\n if directory is not None:\n return Path(directory).resolve()\n\n if relative_fallback:\n app_relative = (app_root_path() / relative_fallback).resolve()\n if app_relative.exists():\n return app_relative\n\n return Path.cwd()\n\n @staticmethod\n def save_path():\n share_dir = os.getenv(\"SHARE_DIR\")\n if share_dir is not None:\n return Path(share_dir)\n return app_root_path()\n\n @staticmethod\n def find_shared_file(file_name):\n share_file_paths = []\n share_dir = os.getenv(\"SHARE_DIR\")\n if share_dir is not None:\n share_file_paths.append(Path(share_dir) / file_name)\n\n share_file_paths.extend(\n [\n app_root_path() / \"share\" / file_name,\n app_root_path() / file_name,\n Path(file_name),\n ]\n )\n\n for share_file_path in share_file_paths:\n if share_file_path.exists():\n return share_file_path.resolve()\n\n raise ValueError(f\"Unable to find shared data file {file_name}\")\n\n @staticmethod\n def get_allowed_guilds():\n # ALLOWED_GUILDS is a comma separated list of guild ids\n # It can also just be one guild ID\n # Read these allowed guilds and return as a list of ints\n try:\n allowed_guilds = os.getenv(\"ALLOWED_GUILDS\")\n except Exception:\n allowed_guilds = None\n\n if allowed_guilds is None:\n raise ValueError(\n \"ALLOWED_GUILDS is not defined properly in the environment file!\"\n \"Please copy your server's guild ID and put it into ALLOWED_GUILDS in the .env file.\"\n 'For example a line should look like: `ALLOWED_GUILDS=\"971268468148166697\"`'\n )\n\n allowed_guilds = (\n allowed_guilds.split(\",\") if \",\" in allowed_guilds else [allowed_guilds]\n )\n allowed_guilds = [int(guild) for guild in allowed_guilds]\n return allowed_guilds\n\n @staticmethod\n def get_described_channels():\n # ALLOWED_GUILDS is a comma separated list of guild ids\n # It can also just be one guild ID\n # Read these allowed guilds and return as a list of ints\n try:\n described_channels = os.getenv(\"DESCRIBED_CHANNELS\")\n except Exception:\n described_channels = None\n\n if described_channels is None:\n raise ValueError(\n \"DESCRIBED_CHANNELS is not properly defined in your environment file. All channels will be enabled for image descriptions\"\n )\n\n described_channels = (\n described_channels.split(\",\")\n if \",\" in described_channels\n else [described_channels]\n )\n return described_channels\n\n @staticmethod\n def get_discord_token():\n try:\n e2b_key = os.getenv(\"DISCORD_TOKEN\")\n return e2b_key\n except Exception:\n return None\n\n @staticmethod\n def get_openai_api_key():\n try:\n openai_key = os.getenv(\"OPENAI_API_KEY\")\n return openai_key\n except Exception:\n return None\n\n @staticmethod\n def get_admin_roles():\n # ADMIN_ROLES is a comma separated list of string roles\n # It can also just be one role\n # Read these allowed roles and return as a list of strings\n try:\n admin_roles = os.getenv(\"ADMIN_ROLES\")\n except Exception:\n admin_roles = None\n\n if admin_roles is None:\n print(\n \"ADMIN_ROLES is not defined properly in the environment file!\"\n \"Please copy your server's role and put it into ADMIN_ROLES in the .env file.\"\n 'For example a line should look like: `ADMIN_ROLES=\"Admin\"`'\n )\n print(\"Defaulting to allowing all users to use admin commands...\")\n return [None]\n\n admin_roles = (\n admin_roles.lower().split(\",\")\n if \",\" in admin_roles\n else [admin_roles.lower()]\n )\n return admin_roles" }, { "identifier": "OpenAIExecutor", "path": "services/openai_service.py", "snippet": "class OpenAIExecutor:\n def __init__(self):\n self.openai_api_key = EnvService.get_openai_api_key()\n try:\n self.ANALYSIS_PRETEXT = IMAGE_ANALYSIS_PROMPT\n except Exception:\n traceback.print_exc()\n self.ANALYSIS_PRETEXT = \"Describe this image in as much detail as you can, for the visually impaired.\"\n\n @backoff.on_exception(\n backoff.expo,\n ValueError,\n factor=3,\n base=5,\n max_tries=4,\n on_backoff=backoff_handler_request,\n )\n async def send_image_evaluation_request(\n self,\n image_urls,\n ):\n messages = [{\"role\": \"system\", \"content\": self.ANALYSIS_PRETEXT}]\n for image_url in image_urls:\n messages.append(\n {\n \"role\": \"user\",\n \"content\": [\n {\n \"type\": \"image_url\",\n \"image_url\": {\"url\": image_url, \"detail\": \"high\"},\n }\n ],\n }\n )\n\n async with aiohttp.ClientSession(\n raise_for_status=False, timeout=aiohttp.ClientTimeout(total=300)\n ) as session:\n payload = {\n \"model\": \"gpt-4-vision-preview\",\n \"messages\": messages,\n \"temperature\": 0,\n \"max_tokens\": 2048,\n }\n\n headers = {\"Authorization\": f\"Bearer {self.openai_api_key}\"}\n\n async with session.post(\n \"https://api.openai.com/v1/chat/completions\",\n json=payload,\n headers=headers,\n ) as resp:\n response = await resp.json()\n # print(f\"Payload -> {payload}\")\n # Parse the total tokens used for this request and response pair from the response\n print(f\"Response -> {response}\")\n\n return response[\"choices\"][0][\"message\"][\"content\"]" } ]

[ { "identifier": "HatchPipCompileError", "path": "hatch_pip_compile/exceptions.py", "snippet": "class HatchPipCompileError(Exception):\n \"\"\"\n Base exception for hatch-pip-compile\n \"\"\"" }, { "identifier": "PipInstaller", "path": "hatch_pip_compile/installer.py", "snippet": "class PipInstaller(PluginInstaller):\n \"\"\"\n Plugin Installer for `pip`\n \"\"\"\n\n def install_dependencies(self) -> None:\n \"\"\"\n Install the dependencies with `pip`\n \"\"\"\n with self.environment.safe_activation():\n if not self.environment.piptools_lock_file.exists():\n return\n extra_args = self.environment.config.get(\"pip-compile-install-args\", [])\n args = [*extra_args, \"--requirement\", str(self.environment.piptools_lock_file)]\n install_command = self.environment.construct_pip_install_command(args=args)\n self.environment.plugin_check_command(install_command)" }, { "identifier": "PipSyncInstaller", "path": "hatch_pip_compile/installer.py", "snippet": "class PipSyncInstaller(PluginInstaller):\n \"\"\"\n Plugin Installer for `pip-sync`\n \"\"\"\n\n def install_dependencies(self) -> None:\n \"\"\"\n Install the dependencies with `pip-sync`\n\n In the event that there are no dependencies, pip-sync will\n uninstall everything in the environment before deleting the\n lockfile.\n \"\"\"\n self.environment.install_pip_tools()\n cmd = [\n self.environment.virtual_env.python_info.executable,\n \"-m\",\n \"piptools\",\n \"sync\",\n \"--verbose\"\n if self.environment.config.get(\"pip-compile-verbose\", None) is True\n else \"--quiet\",\n \"--python-executable\",\n str(self.environment.virtual_env.python_info.executable),\n ]\n if not self.environment.dependencies:\n self.environment.piptools_lock_file.write_text(\"\")\n extra_args = self.environment.config.get(\"pip-compile-install-args\", [])\n cmd.extend(extra_args)\n cmd.append(str(self.environment.piptools_lock_file))\n self.environment.plugin_check_command(cmd)\n if not self.environment.dependencies:\n self.environment.piptools_lock_file.unlink()\n\n def _full_install(self) -> None:\n \"\"\"\n Run the full install process\n\n 1) Run pip-compile (if necessary)\n 2) Run pip-sync\n 3) (re)install project\n \"\"\"\n with self.environment.safe_activation():\n self.environment.run_pip_compile()\n self.install_dependencies()\n if not self.environment.skip_install:\n if self.environment.dev_mode:\n super().install_project_dev_mode()\n else:\n super().install_project()\n\n def sync_dependencies(self):\n \"\"\"\n Sync dependencies\n \"\"\"\n self._full_install()\n\n def install_project(self):\n \"\"\"\n Install the project the first time\n\n The same implementation as `_full_install`\n due to the way `pip-sync` uninstalls our root package\n \"\"\"\n self._full_install()\n\n def install_project_dev_mode(self):\n \"\"\"\n Install the project the first time in dev mode\n\n The same implementation as `_full_install`\n due to the way `pip-sync` uninstalls our root package\n \"\"\"\n self._full_install()" }, { "identifier": "PluginInstaller", "path": "hatch_pip_compile/installer.py", "snippet": "class PluginInstaller(ABC):\n \"\"\"\n Package Installer for the plugin\n\n This abstract base class is used to define the interface for\n how the plugin should install packages and dependencies.\n \"\"\"\n\n environment: \"PipCompileEnvironment\"\n\n @abstractmethod\n def install_dependencies(self) -> None:\n \"\"\"\n Install the dependencies\n \"\"\"\n\n def sync_dependencies(self) -> None:\n \"\"\"\n Sync the dependencies - same as `install_dependencies`\n \"\"\"\n self.install_dependencies()\n\n def install_project(self) -> None:\n \"\"\"\n Install the project (`--no-deps`)\n \"\"\"\n with self.environment.safe_activation():\n self.environment.plugin_check_command(\n self.environment.construct_pip_install_command(\n args=[\"--no-deps\", str(self.environment.root)]\n )\n )\n\n def install_project_dev_mode(self) -> None:\n \"\"\"\n Install the project in editable mode (`--no-deps`)\n \"\"\"\n with self.environment.safe_activation():\n self.environment.plugin_check_command(\n self.environment.construct_pip_install_command(\n args=[\"--no-deps\", \"--editable\", str(self.environment.root)]\n )\n )" }, { "identifier": "PipCompileLock", "path": "hatch_pip_compile/lock.py", "snippet": "class PipCompileLock:\n \"\"\"\n Pip Compile Lock File Operations\n \"\"\"\n\n lock_file: pathlib.Path\n dependencies: List[str]\n project_root: pathlib.Path\n constraints_file: Optional[pathlib.Path]\n env_name: str\n project_name: str\n virtualenv: Optional[VirtualEnv] = None\n\n def process_lock(self, lockfile: pathlib.Path) -> None:\n \"\"\"\n Post process lockfile\n \"\"\"\n version = f\"{self.current_python_version.major}.{self.current_python_version.minor}\"\n raw_prefix = f\"\"\"\n #\n # This file is autogenerated by hatch-pip-compile with Python {version}\n #\n \"\"\"\n prefix = dedent(raw_prefix).strip()\n joined_dependencies = \"\\n\".join([f\"# - {dep}\" for dep in self.dependencies])\n lockfile_text = lockfile.read_text()\n cleaned_input_file = re.sub(\n rf\"-r \\S*/{self.env_name}\\.in\",\n f\"hatch.envs.{self.env_name}\",\n lockfile_text,\n )\n if self.constraints_file is not None:\n constraint_sha = hashlib.sha256(self.constraints_file.read_bytes()).hexdigest()\n constraints_path = self.constraints_file.relative_to(self.project_root).as_posix()\n constraints_line = f\"# [constraints] {constraints_path} (SHA256: {constraint_sha})\"\n joined_dependencies = \"\\n\".join([constraints_line, \"#\", joined_dependencies])\n cleaned_input_file = re.sub(\n r\"-c \\S*\",\n lambda _: f\"-c {constraints_path}\",\n cleaned_input_file,\n )\n prefix += \"\\n\" + joined_dependencies + \"\\n#\"\n new_text = prefix + \"\\n\\n\" + cleaned_input_file\n lockfile.write_text(new_text)\n\n def read_header_requirements(self) -> List[Requirement]:\n \"\"\"\n Read requirements from lock file header\n \"\"\"\n lock_file_text = self.lock_file.read_text()\n parsed_requirements = []\n for line in lock_file_text.splitlines():\n if line.startswith(\"# - \"):\n requirement = Requirement(line[4:])\n parsed_requirements.append(requirement)\n elif not line.startswith(\"#\"):\n break\n return parsed_requirements\n\n @property\n def current_python_version(self) -> Version:\n \"\"\"\n Get python version\n\n In the case of running as a hatch plugin, the `virtualenv` will be set,\n otherwise it will be None and the Python version will be read differently.\n \"\"\"\n if self.virtualenv is not None:\n return Version(self.virtualenv.environment[\"python_version\"])\n else:\n msg = \"VirtualEnv is not set\"\n raise NotImplementedError(msg)\n\n @property\n def lock_file_version(self) -> Version:\n \"\"\"\n Get lock file version\n \"\"\"\n lock_file_text = self.lock_file.read_text()\n match = re.search(\n r\"# This file is autogenerated by hatch-pip-compile with Python (.*)\", lock_file_text\n )\n if match is None:\n msg = \"Could not find lock file python version\"\n raise LockFileError(msg)\n return Version(match.group(1))\n\n def compare_python_versions(self, verbose: Optional[bool] = None) -> bool:\n \"\"\"\n Compare python versions\n\n Parameters\n ----------\n verbose : Optional[bool]\n Print warning if python versions are different, by default None\n which will print the warning. Used as a plugin flag.\n \"\"\"\n lock_version = self.lock_file_version\n current_version = self.current_python_version\n match = (current_version.major == lock_version.major) and (\n current_version.minor == lock_version.minor\n )\n if match is False and verbose is not False:\n logger.error(\n \"[hatch-pip-compile] Your Python version is different \"\n \"from the lock file, your results may vary.\"\n )\n return lock_version == current_version\n\n def compare_requirements(self, requirements: Iterable[Requirement]) -> bool:\n \"\"\"\n Compare requirements\n\n Parameters\n ----------\n requirements : Iterable[Requirement]\n List of requirements to compare against the lock file\n \"\"\"\n lock_requirements = self.read_header_requirements()\n return set(requirements) == set(lock_requirements)\n\n def compare_constraint_sha(self, sha: str) -> bool:\n \"\"\"\n Compare SHA to the SHA on the lockfile\n \"\"\"\n lock_file_text = self.lock_file.read_text()\n match = re.search(r\"# \\[constraints\\] \\S* \\(SHA256: (.*)\\)\", lock_file_text)\n if match is None:\n return False\n return match.group(1).strip() == sha.strip()\n\n def get_file_content_hash(self) -> str:\n \"\"\"\n Get hash of lock file\n \"\"\"\n return hashlib.sha256(self.lock_file.read_bytes()).hexdigest()\n\n def read_lock_requirements(self) -> List[Requirement]:\n \"\"\"\n Read all requirements from lock file\n \"\"\"\n if not self.dependencies:\n return []\n install_requirements = parse_requirements(\n str(self.lock_file),\n session=PipSession(),\n )\n return [ireq.req for ireq in install_requirements] # type: ignore[misc]" } ]

[ { "identifier": "env_utils", "path": "pix2act/common/env_utils.py", "snippet": "class EnvConfig:\nclass CursorState:\ndef rel_x_y_to_x_y(env_config, x_rel, y_rel):\ndef is_float(element: str) -> bool:\ndef is_valid_coordinate(env_config: EnvConfig, x_str: str, y_str: str) -> bool:\ndef is_valid(env_config, action_str):\ndef filter_predictions(env_config, predictions):\ndef process_action(\n driver,\n env_config,\n cursor_state,\n action_str,\n):\ndef _key_press(driver, key, key_hold=None):\ndef _scroll(driver, delta_y, get_scrollable_element_fn):\ndef _ptr_move(driver, cursor_state, x, y):\ndef _ptr_down(driver, cursor_state):\ndef _ptr_up(driver, cursor_state):\ndef _double_click(driver):\ndef _click(driver, cursor_state, x, y):\ndef create_web_driver(chrome_options):\ndef get_screenshot(driver, env_config, cursor_state):\ndef get_screenshot_as_png(driver, env_config, cursor_state):\ndef get_cursor_type(driver, cursor_state):" }, { "identifier": "render_utils", "path": "pix2act/common/render_utils.py", "snippet": "def get_cursor(cursor_dir: str, filename: str) -> Image.Image:\ndef image_to_png(image: Image.Image) -> bytes:\ndef png_to_image(image_png: bytes) -> Image.Image:\ndef create_empty_image_of_size(size: Tuple[int, int]) -> Image.Image:\ndef crop(screenshot: Image.Image, width: int, height: int) -> Image.Image:\ndef add_cursor(\n cursor_dir: str, screenshot: Image.Image, cursor_state\n) -> Image.Image:\ndef augment_screenshot(image: Image.Image, render_marker: bool) -> Image.Image:\ndef render_header(\n image: Image.Image, header: str, background_color: str\n) -> Image.Image:\ndef render_action_history(\n image: Image.Image,\n history: str,\n max_action_chars: int,\n):" }, { "identifier": "tf_utils", "path": "pix2act/common/tf_utils.py", "snippet": "def add_bytes_feature(\n example: tf.train.Example, key: str, value: bytes\n) -> None:\ndef add_text_feature(example: tf.train.Example, key: str, value: str) -> None:\ndef get_bytes_feature(example: tf.train.Example, key: str) -> bytes:\ndef get_text_feature(example: tf.train.Example, key: str) -> str:\ndef _get_hash(key: str) -> int:\ndef _increment_counter(item, counter):\n def __init__(\n self,\n output_dir: str,\n validation_percent: Optional[int] = 10,\n train_file_name: str = \"train.tfr\",\n val_file_name: str = \"val.tfr\",\n ):\n def _partition_index(\n self, example: tf.train.Example, unused_num_partitions: int\n ) -> int:\n def expand(self, pcoll):\nclass SplitAndWriteTFRecords(beam.PTransform):" }, { "identifier": "demo_utils", "path": "pix2act/tasks/webshop/demo_utils.py", "snippet": "ACTION_BUTTONS = frozenset([\n \"back to search\",\n \"next >\",\n \"< prev\",\n \"description\",\n \"features\",\n \"reviews\",\n \"attributes\",\n \"buy now\",\n])\n_EPISODE_END_TEXT = \"Thank you for shopping with us!\"\nSPLITS = {\"train\": (1500, 12087), \"val\": (500, 1500), \"test\": (0, 500)}\ndef maybe_prepend_instruction(\n instruction_text: str, prepend_instruction: int\n) -> str:\ndef format_action(action: str) -> str:\ndef get_action_history(\n prev_examples,\n num_previous_actions,\n action_key=\"parse\") -> str:\ndef process_goal(state, human_goals):\ndef get_split(goal_idx):\ndef read_goals_file(human_goals_file: str):\ndef read_demos_file(demo_file: str):\ndef get_reward(driver) -> float:\ndef is_episode_done(driver):\ndef get_instruction_text(driver) -> str:\ndef x_y_to_rel_x_y(x: int, y: int) -> Tuple[int, int]:\ndef get_click_coordinates(driver, element) -> Tuple[int, int]:\ndef _normalize_str(x):\ndef get_element(driver, arg, arg_translated):\ndef is_coordinate_not_in_full_view(click_y: int) -> bool:\ndef coordinate_needs_down_scroll(click_y: int) -> bool:\ndef coordinate_needs_up_scroll(click_y: int) -> bool:\ndef is_scrollable(driver, scroll_y: int) -> bool:\ndef convert_action(\n driver, action, action_translated, word_input_to_search\n) -> Iterable[Tuple[str, str]]:" }, { "identifier": "webshop_env", "path": "pix2act/tasks/webshop/webshop_env.py", "snippet": "WIDTH = 800\nHEIGHT = 600\nNUM_X_BUCKETS = 100\nNUM_Y_BUCKETS = 100\nCENTER_BUCKETS = False\nSCROLLABLE_ELEMENT_FN = \"window\"\ndef get_env_config(cursor_dir):" } ]

[ { "identifier": "TRANSFORMER_DECODER_REGISTRY", "path": "mask2former/modeling/transformer_decoder/maskformer_transformer_decoder.py", "snippet": "TRANSFORMER_DECODER_REGISTRY = Registry(\"TRANSFORMER_MODULE\")" }, { "identifier": "PositionEmbeddingSine3D", "path": "mask2former_video/modeling/transformer_decoder/position_encoding.py", "snippet": "class PositionEmbeddingSine3D(nn.Module):\n \"\"\"\n This is a more standard version of the position embedding, very similar to the one\n used by the Attention is all you need paper, generalized to work on images.\n \"\"\"\n\n def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):\n super().__init__()\n self.num_pos_feats = num_pos_feats\n self.temperature = temperature\n self.normalize = normalize\n if scale is not None and normalize is False:\n raise ValueError(\"normalize should be True if scale is passed\")\n if scale is None:\n scale = 2 * math.pi\n self.scale = scale\n\n def forward(self, x, mask=None):\n # b, t, c, h, w\n assert x.dim() == 5, f\"{x.shape} should be a 5-dimensional Tensor, got {x.dim()}-dimensional Tensor instead\"\n if mask is None:\n mask = torch.zeros((x.size(0), x.size(1), x.size(3), x.size(4)), device=x.device, dtype=torch.bool)\n not_mask = ~mask\n z_embed = not_mask.cumsum(1, dtype=torch.float32)\n y_embed = not_mask.cumsum(2, dtype=torch.float32)\n x_embed = not_mask.cumsum(3, dtype=torch.float32)\n if self.normalize:\n eps = 1e-6\n z_embed = z_embed / (z_embed[:, -1:, :, :] + eps) * self.scale\n y_embed = y_embed / (y_embed[:, :, -1:, :] + eps) * self.scale\n x_embed = x_embed / (x_embed[:, :, :, -1:] + eps) * self.scale\n\n dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)\n dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)\n\n dim_t_z = torch.arange((self.num_pos_feats * 2), dtype=torch.float32, device=x.device)\n dim_t_z = self.temperature ** (2 * (dim_t_z // 2) / (self.num_pos_feats * 2))\n\n pos_x = x_embed[:, :, :, :, None] / dim_t\n pos_y = y_embed[:, :, :, :, None] / dim_t\n pos_z = z_embed[:, :, :, :, None] / dim_t_z\n pos_x = torch.stack((pos_x[:, :, :, :, 0::2].sin(), pos_x[:, :, :, :, 1::2].cos()), dim=5).flatten(4)\n pos_y = torch.stack((pos_y[:, :, :, :, 0::2].sin(), pos_y[:, :, :, :, 1::2].cos()), dim=5).flatten(4)\n pos_z = torch.stack((pos_z[:, :, :, :, 0::2].sin(), pos_z[:, :, :, :, 1::2].cos()), dim=5).flatten(4)\n pos = (torch.cat((pos_y, pos_x), dim=4) + pos_z).permute(0, 1, 4, 2, 3) # b, t, c, h, w\n return pos" } ]

[ { "identifier": "OPERATORS", "path": "data_modori/ops/base_op.py", "snippet": "OPERATORS = Registry('Operators')" }, { "identifier": "setup_logger", "path": "data_modori/utils/logger_utils.py", "snippet": "def setup_logger(save_dir, distributed_rank=0, filename='log.txt', mode='o', redirect=True):\n \"\"\"\n Setup logger for training and testing.\n\n :param save_dir: location to save log file\n :param distributed_rank: device rank when multi-gpu environment\n :param filename: log file name to save\n :param mode: log file write mode, `append` or `override`. default is `o`.\n :param redirect: whether to redirect system output\n :return: logger instance.\n \"\"\"\n global LOGGER_SETUP\n\n if LOGGER_SETUP:\n return\n\n loguru_format = (\n '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | '\n '<level>{level: <8}</level> | '\n '<cyan>{name}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>')\n\n logger.remove()\n save_file = os.path.join(save_dir, filename)\n if mode == 'o' and os.path.exists(save_file):\n os.remove(save_file)\n\n # only keep logger in rank0 process\n if distributed_rank == 0:\n logger.add(\n sys.stderr,\n format=loguru_format,\n level='INFO',\n enqueue=True,\n )\n logger.add(save_file)\n\n # redirect stdout/stderr to loguru\n if redirect:\n redirect_sys_output('INFO')\n LOGGER_SETUP = True" } ]

[ { "identifier": "read_yaml", "path": "pylmkit/utils/data_utils.py", "snippet": "def read_yaml(filepath):\n try:\n with open(filepath, encoding=\"utf-8\") as fp:\n result = yaml.load(fp, Loader=SafeLoader)\n except Exception as e:\n raise Exception(e)\n return result" }, { "identifier": "read_json", "path": "pylmkit/utils/data_utils.py", "snippet": "def read_json(filepath, mode='r', encoding='utf-8'):\n with open(filepath, mode, encoding=encoding) as fp:\n data = json.load(fp)\n return data" }, { "identifier": "write_yaml", "path": "pylmkit/utils/data_utils.py", "snippet": "def write_yaml(data, filepath, mode=\"w\", encoding='utf-8'):\n try:\n with open(filepath, mode=mode, encoding=encoding) as f:\n yaml.dump(data=data, stream=f, allow_unicode=True)\n except Exception as e:\n raise Exception(e)" }, { "identifier": "write_json", "path": "pylmkit/utils/data_utils.py", "snippet": "def write_json(data, filepath, mode='w', encoding='utf-8', ensure_ascii=False):\n with open(filepath, mode, encoding=encoding) as fp:\n json.dump(data, # 字典数据\n fp=fp, # open 文件\n ensure_ascii=ensure_ascii, # 确保中文无乱码\n )" }, { "identifier": "message_as_string", "path": "pylmkit/utils/data_utils.py", "snippet": "def message_as_string(memory_messages):\n messages_string = [f\"\\n{message['role']}: {message['content']}\" for message in memory_messages]\n return \"\".join(messages_string)" }, { "identifier": "document_as_dict", "path": "pylmkit/utils/data_utils.py", "snippet": "def document_as_dict(documents):\n document_dict = [{\"page_content\": doc.page_content, \"metadata\": doc.metadata,\n \"type\": doc.type} for doc in documents]\n return document_dict" }, { "identifier": "dict_as_document", "path": "pylmkit/utils/data_utils.py", "snippet": "def dict_as_document(doc_dict):\n document_dict = [Document(page_content=doc['page_content'],\n metadata=doc.get('metadata', {}),\n type=doc.get('type', 'Document')) for doc in doc_dict]\n return document_dict" }, { "identifier": "BaseLoader", "path": "pylmkit/perception/directory.py", "snippet": "FILE_LOADER_TYPE = Union[\n Type[UnstructuredFileLoader], Type[TextLoader], Type[BSHTMLLoader]\n]\ndef _is_visible(p: Path) -> bool:\n def __init__(\n self,\n path: str,\n glob: str = \"**/[!.]*\",\n suffixes: Optional[Sequence[str]] = None, # Modifying\n silent_errors: bool = False,\n load_hidden: bool = False,\n loader_cls=None,\n loader_kwargs: Union[dict, None] = None,\n recursive: bool = False,\n show_progress: bool = False,\n use_multithreading: bool = False,\n max_concurrency: int = 4,\n *,\n sample_size: int = 0,\n randomize_sample: bool = False,\n sample_seed: Union[int, None] = None,\n ):\n def load_file(\n self, item: Path, path: Path, docs: List[Document], pbar: Optional[Any]\n ) -> None:\n def load(self) -> List[Document]:\nclass DirectoryLoader(BaseLoader):" }, { "identifier": "text_as_document", "path": "pylmkit/utils/data_utils.py", "snippet": "def text_as_document(texts, metadatas=None, types=\"Document\"):\n documents = []\n if metadatas:\n if isinstance(types, str):\n for i, text in enumerate(texts):\n documents.append(Document(page_content=text, metadata=metadatas[i], type=types))\n else: # types is `list` mode\n for i, text in enumerate(texts):\n documents.append(Document(page_content=text, metadata=metadatas[i], type=types[i]))\n else:\n if isinstance(types, str):\n for i, text in enumerate(texts):\n documents.append(Document(page_content=text, type=types))\n else: # types is `list` mode\n for i, text in enumerate(texts):\n documents.append(Document(page_content=text, type=types[i]))\n return documents" }, { "identifier": "RecursiveCharacterTextSplitter", "path": "pylmkit/perception/directory.py", "snippet": "FILE_LOADER_TYPE = Union[\n Type[UnstructuredFileLoader], Type[TextLoader], Type[BSHTMLLoader]\n]\ndef _is_visible(p: Path) -> bool:\n def __init__(\n self,\n path: str,\n glob: str = \"**/[!.]*\",\n suffixes: Optional[Sequence[str]] = None, # Modifying\n silent_errors: bool = False,\n load_hidden: bool = False,\n loader_cls=None,\n loader_kwargs: Union[dict, None] = None,\n recursive: bool = False,\n show_progress: bool = False,\n use_multithreading: bool = False,\n max_concurrency: int = 4,\n *,\n sample_size: int = 0,\n randomize_sample: bool = False,\n sample_seed: Union[int, None] = None,\n ):\n def load_file(\n self, item: Path, path: Path, docs: List[Document], pbar: Optional[Any]\n ) -> None:\n def load(self) -> List[Document]:\nclass DirectoryLoader(BaseLoader):" }, { "identifier": "init_css", "path": "pylmkit/core/html.py", "snippet": "" }, { "identifier": "_zh", "path": "pylmkit/core/html.py", "snippet": "" } ]

[ { "identifier": "ACTIONS", "path": "pokegym/pyboy_binding.py", "snippet": "ACTIONS = (Down, Left, Right, Up, A, B, Start, Select)" }, { "identifier": "make_env", "path": "pokegym/pyboy_binding.py", "snippet": "def make_env(gb_path, headless=True, quiet=False, **kwargs):\n gb_path='pokemon_red.gb'\n game = PyBoy(\n gb_path,\n debugging=False,\n window_type='headless' if headless else 'SDL2',\n hide_window=quiet,\n **kwargs,\n )\n\n screen = game.botsupport_manager().screen()\n\n if not headless:\n game.set_emulation_speed(6)\n\n return game, screen" }, { "identifier": "open_state_file", "path": "pokegym/pyboy_binding.py", "snippet": "def open_state_file(path):\n '''Load state file with BytesIO so we can cache it'''\n with open(path, 'rb') as f:\n initial_state = BytesIO(f.read())\n\n return initial_state" }, { "identifier": "load_pyboy_state", "path": "pokegym/pyboy_binding.py", "snippet": "def load_pyboy_state(pyboy, state):\n '''Reset state stream and load it into PyBoy'''\n state.seek(0)\n pyboy.load_state(state)" }, { "identifier": "run_action_on_emulator", "path": "pokegym/pyboy_binding.py", "snippet": "def run_action_on_emulator(pyboy, screen, action,\n headless=True, fast_video=True, frame_skip=24):\n '''Sends actions to PyBoy'''\n press, release = action.PRESS, action.RELEASE\n pyboy.send_input(press)\n\n if headless or fast_video:\n pyboy._rendering(False)\n\n frames = []\n for i in range(frame_skip):\n if i == 8: # Release button after 8 frames\n pyboy.send_input(release)\n if not fast_video: # Save every frame\n frames.append(screen.screen_ndarray())\n if i == frame_skip - 1:\n pyboy._rendering(True)\n pyboy.tick()\n\n if fast_video: # Save only the last frame\n frames.append(screen.screen_ndarray())" }, { "identifier": "ram_map", "path": "pokegym/ram_map.py", "snippet": "HP_ADDR = [0xD16C, 0xD198, 0xD1C4, 0xD1F0, 0xD21C, 0xD248]\nMAX_HP_ADDR = [0xD18D, 0xD1B9, 0xD1E5, 0xD211, 0xD23D, 0xD269]\nPARTY_SIZE_ADDR = 0xD163\nPARTY_ADDR = [0xD164, 0xD165, 0xD166, 0xD167, 0xD168, 0xD169]\nPARTY_LEVEL_ADDR = [0xD18C, 0xD1B8, 0xD1E4, 0xD210, 0xD23C, 0xD268]\nPOKE_XP_ADDR = [0xD179, 0xD1A5, 0xD1D1, 0xD1FD, 0xD229, 0xD255]\nCAUGHT_POKE_ADDR = range(0xD2F7, 0xD309)\nSEEN_POKE_ADDR = range(0xD30A, 0xD31D)\nOPPONENT_LEVEL_ADDR = [0xD8C5, 0xD8F1, 0xD91D, 0xD949, 0xD975, 0xD9A1]\nX_POS_ADDR = 0xD362\nY_POS_ADDR = 0xD361\nMAP_N_ADDR = 0xD35E\nBADGE_1_ADDR = 0xD356\nOAK_PARCEL_ADDR = 0xD74E\nOAK_POKEDEX_ADDR = 0xD74B\nOPPONENT_LEVEL = 0xCFF3\nENEMY_POKE_COUNT = 0xD89C\nEVENT_FLAGS_START_ADDR = 0xD747\nEVENT_FLAGS_END_ADDR = 0xD761\nMUSEUM_TICKET_ADDR = 0xD754\nMONEY_ADDR_1 = 0xD347\nMONEY_ADDR_100 = 0xD348\nMONEY_ADDR_10000 = 0xD349\ndef bcd(num):\ndef bit_count(bits):\ndef read_bit(game, addr, bit) -> bool:\ndef read_uint16(game, start_addr):\ndef position(game):\ndef party(game):\ndef opponent(game):\ndef oak_parcel(game):\ndef pokedex_obtained(game):\ndef pokemon_seen(game):\ndef pokemon_caught(game):\ndef hp(game):\ndef money(game):\ndef badges(game):\ndef events(game):" }, { "identifier": "game_map", "path": "pokegym/game_map.py", "snippet": "MAP_PATH = __file__.rstrip('game_map.py') + 'map_data.json'\nMAP_DATA = json.load(open(MAP_PATH, 'r'))['regions']\nMAP_DATA = {int(e['id']): e for e in MAP_DATA}\ndef local_to_global(r, c, map_n):" } ]

[ { "identifier": "DOMAIN", "path": "custom_components/flightradar24/const.py", "snippet": "DOMAIN = \"flightradar24\"" }, { "identifier": "FlightRadar24Coordinator", "path": "custom_components/flightradar24/coordinator.py", "snippet": "class FlightRadar24Coordinator(DataUpdateCoordinator[int]):\n\n def __init__(\n self,\n hass: HomeAssistant,\n bound: BoundingBox,\n client: FlightRadar24API,\n update_interval: int,\n logger: Logger,\n ) -> None:\n\n self._bound = bound\n self._client = client\n self._logger = logger\n self.tracked: dict[int, dict[str, Any]] | None = None\n self.entered = {}\n self.exited = {}\n self.device_info = DeviceInfo(\n configuration_url=URL,\n identifiers={(DOMAIN, DEFAULT_NAME)},\n manufacturer=DEFAULT_NAME,\n name=DEFAULT_NAME,\n )\n\n super().__init__(\n hass,\n logger,\n name=DOMAIN,\n update_interval=timedelta(seconds=update_interval),\n )\n\n @staticmethod\n def get_bounding_box(\n latitude: float,\n longitude: float,\n radius: float,\n ) -> BoundingBox:\n \"\"\"Get bounding box from radius and a point.\"\"\"\n half_side_in_km = abs(radius) / 1000\n\n lat = math.radians(latitude)\n lon = math.radians(longitude)\n\n approx_earth_radius = 6371\n hypotenuse_distance = math.sqrt(2 * (math.pow(half_side_in_km, 2)))\n\n lat_min = math.asin(\n math.sin(lat) * math.cos(hypotenuse_distance / approx_earth_radius)\n + math.cos(lat)\n * math.sin(hypotenuse_distance / approx_earth_radius)\n * math.cos(225 * (math.pi / 180)),\n )\n lon_min = lon + math.atan2(\n math.sin(225 * (math.pi / 180))\n * math.sin(hypotenuse_distance / approx_earth_radius)\n * math.cos(lat),\n math.cos(hypotenuse_distance / approx_earth_radius)\n - math.sin(lat) * math.sin(lat_min),\n )\n\n lat_max = math.asin(\n math.sin(lat) * math.cos(hypotenuse_distance / approx_earth_radius)\n + math.cos(lat)\n * math.sin(hypotenuse_distance / approx_earth_radius)\n * math.cos(45 * (math.pi / 180)),\n )\n lon_max = lon + math.atan2(\n math.sin(45 * (math.pi / 180))\n * math.sin(hypotenuse_distance / approx_earth_radius)\n * math.cos(lat),\n math.cos(hypotenuse_distance / approx_earth_radius)\n - math.sin(lat) * math.sin(lat_max),\n )\n\n rad2deg = math.degrees\n\n return BoundingBox(\n min_latitude=rad2deg(lat_min),\n max_latitude=rad2deg(lat_max),\n min_longitude=rad2deg(lon_min),\n max_longitude=rad2deg(lon_max),\n )\n\n async def _async_update_data(self):\n self.entered = {}\n self.exited = {}\n try:\n flights = await self.hass.async_add_executor_job(\n self._client.get_flights, None, self._bound.get_string()\n )\n current: dict[int, dict[str, Any]] = {}\n for obj in flights:\n if self.tracked is not None and obj.id in self.tracked and self._is_valid(self.tracked[obj.id]):\n flight = self.tracked[obj.id]\n else:\n data = await self.hass.async_add_executor_job(\n self._client.get_flight_details, obj\n )\n flight = self._get_flight_data(data)\n if flight is not None:\n current[flight['id']] = flight\n flight['latitude'] = obj.latitude\n flight['longitude'] = obj.longitude\n flight['altitude'] = obj.altitude\n flight['heading'] = obj.heading\n flight['ground_speed'] = obj.ground_speed\n flight['squawk'] = obj.squawk\n\n if self.tracked is not None:\n entries = current.keys() - self.tracked.keys()\n self.entered = [current[x] for x in entries]\n exits = self.tracked.keys() - current.keys()\n self.exited = [self.tracked[x] for x in exits]\n self._handle_boundary(EVENT_FLIGHTRADAR24_ENTRY, self.entered)\n self._handle_boundary(EVENT_FLIGHTRADAR24_EXIT, self.exited)\n self.tracked = current\n\n except Exception as e:\n self._logger.error(e)\n\n def _handle_boundary(self, event: str, flights: list[dict[str, Any]]) -> None:\n for flight in flights:\n self.hass.bus.fire(event, flight)\n\n @staticmethod\n def _get_value(dictionary: dict, keys: list) -> Any | None:\n nested_dict = dictionary\n\n for key in keys:\n try:\n nested_dict = nested_dict[key]\n except Exception:\n return None\n return nested_dict\n\n @staticmethod\n def _is_valid(flight: dict) -> bool:\n return flight['flight_number'] is not None\n\n @staticmethod\n def _get_country_code(code: None | str) -> None | str:\n if code is None or len(code) == 2:\n return code\n country = pycountry.countries.get(alpha_3=code)\n\n return country.alpha_2 if country is not None else code\n\n @staticmethod\n def _get_flight_data(flight: dict) -> dict[str, Any] | None:\n flight_id = FlightRadar24Coordinator._get_value(flight, ['identification', 'id'])\n if flight_id is None:\n return None\n\n return {\n 'id': flight_id,\n 'flight_number': FlightRadar24Coordinator._get_value(flight, ['identification', 'number', 'default']),\n 'callsign': FlightRadar24Coordinator._get_value(flight, ['identification', 'callsign']),\n 'aircraft_registration': FlightRadar24Coordinator._get_value(flight, ['aircraft', 'registration']),\n 'aircraft_photo_small': FlightRadar24Coordinator._get_value(flight,\n ['aircraft', 'images', 'thumbnails', 0, 'src']),\n 'aircraft_model': FlightRadar24Coordinator._get_value(flight, ['aircraft', 'model', 'text']),\n 'aircraft_code': FlightRadar24Coordinator._get_value(flight, ['aircraft', 'model', 'code']),\n 'airline': FlightRadar24Coordinator._get_value(flight, ['airline', 'name']),\n 'airline_short': FlightRadar24Coordinator._get_value(flight, ['airline', 'short']),\n 'airline_iata': FlightRadar24Coordinator._get_value(flight, ['airline', 'code', 'iata']),\n 'airline_icao': FlightRadar24Coordinator._get_value(flight, ['airline', 'code', 'icao']),\n 'airport_origin_name': FlightRadar24Coordinator._get_value(flight, ['airport', 'origin', 'name']),\n 'airport_origin_code_iata': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'origin', 'code', 'iata']),\n 'airport_origin_code_icao': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'origin', 'code', 'icao']),\n 'airport_origin_country_name': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'origin', 'position',\n 'country', 'name']),\n 'airport_origin_country_code': FlightRadar24Coordinator._get_country_code(\n FlightRadar24Coordinator._get_value(flight,['airport', 'origin', 'position', 'country', 'code'])),\n 'airport_origin_city': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'origin', 'position', 'region',\n 'city']),\n 'airport_destination_name': FlightRadar24Coordinator._get_value(flight, ['airport', 'destination', 'name']),\n 'airport_destination_code_iata': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'destination', 'code',\n 'iata']),\n 'airport_destination_code_icao': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'destination', 'code',\n 'icao']),\n 'airport_destination_country_name': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'destination',\n 'position', 'country',\n 'name']),\n 'airport_destination_country_code': FlightRadar24Coordinator._get_country_code(\n FlightRadar24Coordinator._get_value(flight,\n ['airport', 'destination', 'position', 'country', 'code'])),\n 'airport_destination_city': FlightRadar24Coordinator._get_value(flight,\n ['airport', 'destination', 'position',\n 'region', 'city']),\n 'time_scheduled_departure': FlightRadar24Coordinator._get_value(flight, ['time', 'scheduled', 'departure']),\n 'time_scheduled_arrival': FlightRadar24Coordinator._get_value(flight, ['time', 'scheduled', 'arrival']),\n 'time_real_departure': FlightRadar24Coordinator._get_value(flight, ['time', 'real', 'departure']),\n 'time_real_arrival': FlightRadar24Coordinator._get_value(flight, ['time', 'real', 'arrival']),\n }" } ]

[ { "identifier": "BasicTrainer", "path": "TextEE/models/trainer.py", "snippet": "class BasicTrainer(object):\n def __init__(self, config, type_set=None):\n self.config = config\n self.type_set = type_set\n \n @classmethod\n def add_extra_info_fn(cls, instances, raw_data, config):\n for instance in instances:\n instance[\"extra_info\"] = None\n return instances\n \n def load_model(self, checkpoint=None):\n pass\n \n def train(self, train_data, dev_data, **kwargs):\n pass\n \n def predict(self, data, **kwargs):\n pass" }, { "identifier": "EEQAEDModel", "path": "TextEE/models/EEQA/EDmodel.py", "snippet": "class EEQAEDModel(nn.Module):\n def __init__(self, config, tokenizer, type_set):\n super().__init__()\n self.config = config\n self.tokenizer = tokenizer\n self.type_set = type_set\n self.generate_tagging_vocab()\n \n # base encoder\n if self.config.pretrained_model_name.startswith('bert-'):\n self.tokenizer.bos_token = self.tokenizer.cls_token\n self.tokenizer.eos_token = self.tokenizer.sep_token\n self.base_config = BertConfig.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir)\n self.base_model = BertModel.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir, \n output_hidden_states=True)\n elif self.config.pretrained_model_name.startswith('roberta-'):\n self.base_config = RobertaConfig.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir)\n self.base_model = RobertaModel.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir, \n output_hidden_states=True)\n elif self.config.pretrained_model_name.startswith('xlm-'):\n self.base_config = XLMRobertaConfig.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir)\n self.base_model = XLMRobertaModel.from_pretrained(self.config.pretrained_model_name, \n cache_dir=self.config.cache_dir, \n output_hidden_states=True)\n else:\n raise ValueError(f\"pretrained_model_name is not supported.\")\n \n self.base_model.resize_token_embeddings(len(self.tokenizer))\n self.base_model_dim = self.base_config.hidden_size\n self.base_model_dropout = nn.Dropout(p=self.config.base_model_dropout)\n \n # local classifiers\n self.dropout = nn.Dropout(p=self.config.linear_dropout)\n feature_dim = self.base_model_dim\n\n self.trigger_label_ffn = Linears([feature_dim, len(self.type_stoi[\"trigger\"])],\n dropout_prob=self.config.linear_dropout, \n bias=self.config.linear_bias, \n activation=self.config.linear_activation)\n \n def generate_tagging_vocab(self):\n trigger_type_itos = ['O'] + [t for t in sorted(self.type_set[\"trigger\"])]\n trigger_type_stoi = {t: i for i, t in enumerate(trigger_type_itos)}\n self.type_itos = {\"trigger\": trigger_type_itos}\n self.type_stoi = {\"trigger\": trigger_type_stoi}\n \n def token_lens_to_offsets(self, token_lens):\n \"\"\"Map token lengths to first word piece indices, used by the sentence\n encoder.\n :param token_lens (list): token lengths (word piece numbers)\n :return (list): first word piece indices (offsets)\n \"\"\"\n max_token_num = max([len(x) for x in token_lens])\n offsets = []\n for seq_token_lens in token_lens:\n seq_offsets = [0]\n for l in seq_token_lens[:-1]:\n seq_offsets.append(seq_offsets[-1] + l)\n offsets.append(seq_offsets + [-1] * (max_token_num - len(seq_offsets)))\n return offsets\n \n def token_lens_to_idxs(self, token_lens):\n \"\"\"Map token lengths to a word piece index matrix (for torch.gather) and a\n mask tensor.\n For example (only show a sequence instead of a batch):\n token lengths: [1,1,1,3,1]\n =>\n indices: [[0,0,0], [1,0,0], [2,0,0], [3,4,5], [6,0,0]]\n masks: [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0],\n [0.33, 0.33, 0.33], [1.0, 0.0, 0.0]]\n Next, we use torch.gather() to select vectors of word pieces for each token,\n and average them as follows (incomplete code):\n outputs = torch.gather(bert_outputs, 1, indices) * masks\n outputs = bert_outputs.view(batch_size, seq_len, -1, self.bert_dim)\n outputs = bert_outputs.sum(2)\n :param token_lens (list): token lengths.\n :return: a index matrix and a mask tensor.\n \"\"\"\n max_token_num = max([len(x) for x in token_lens])\n max_token_len = max([max(x) for x in token_lens])\n idxs, masks = [], []\n for seq_token_lens in token_lens:\n seq_idxs, seq_masks = [], []\n offset = 0\n for token_len in seq_token_lens:\n seq_idxs.extend([i + offset for i in range(token_len)]\n + [-1] * (max_token_len - token_len))\n seq_masks.extend([1.0 / token_len] * token_len\n + [0.0] * (max_token_len - token_len))\n offset += token_len\n seq_idxs.extend([-1] * max_token_len * (max_token_num - len(seq_token_lens)))\n seq_masks.extend([0.0] * max_token_len * (max_token_num - len(seq_token_lens)))\n idxs.append(seq_idxs)\n masks.append(seq_masks)\n return idxs, masks, max_token_num, max_token_len\n \n def process_data(self, batch):\n enc_idxs = []\n enc_attn = []\n trigger_seqidxs = []\n token_lens = []\n token_nums = []\n max_token_num = max(batch.batch_token_num)\n \n for tokens, pieces, triggers, token_len, token_num in zip(batch.batch_tokens, batch.batch_pieces, batch.batch_triggers, \n batch.batch_token_lens, batch.batch_token_num):\n\n piece_id = self.tokenizer.convert_tokens_to_ids(pieces)\n \n if self.config.question_type == \"verb\":\n question = \"verb\"\n question_pieces = self.tokenizer.tokenize(question, is_split_into_words=True)\n question_idx = self.tokenizer.convert_tokens_to_ids(question_pieces)\n \n enc_idx = [self.tokenizer.convert_tokens_to_ids(self.tokenizer.bos_token)] + question_idx + \\\n [self.tokenizer.convert_tokens_to_ids(self.tokenizer.sep_token)] + piece_id + [self.tokenizer.convert_tokens_to_ids(self.tokenizer.eos_token)]\n \n enc_idxs.append(enc_idx)\n enc_attn.append([1]*len(enc_idx))\n self.question_offset = len(question_idx) + 2\n \n token_lens.append(token_len)\n token_nums.append(token_num)\n \n labels = ['O'] * token_num\n for trigger in triggers:\n if labels[trigger[0]] == 'O':\n labels[trigger[0]] = trigger[2]\n \n trigger_seqidxs.append([self.type_stoi[\"trigger\"][s] for s in labels] + [-100] * (max_token_num-len(tokens)))\n\n max_len = max([len(enc_idx) for enc_idx in enc_idxs])\n enc_idxs = torch.LongTensor([enc_idx + [self.tokenizer.convert_tokens_to_ids(self.tokenizer.pad_token)]*(max_len-len(enc_idx)) for enc_idx in enc_idxs])\n enc_attn = torch.LongTensor([enc_att + [0]*(max_len-len(enc_att)) for enc_att in enc_attn])\n enc_idxs = enc_idxs.cuda()\n enc_attn = enc_attn.cuda()\n trigger_seqidxs = torch.cuda.LongTensor(trigger_seqidxs)\n return enc_idxs, enc_attn, trigger_seqidxs, token_lens, torch.cuda.LongTensor(token_nums)\n \n def encode(self, piece_idxs, attention_masks, token_lens):\n \"\"\"Encode input sequences with BERT\n :param piece_idxs (LongTensor): word pieces indices\n :param attention_masks (FloatTensor): attention mask\n :param token_lens (list): token lengths\n \"\"\"\n batch_size, _ = piece_idxs.size()\n all_base_model_outputs = self.base_model(piece_idxs, attention_mask=attention_masks)\n base_model_outputs = all_base_model_outputs[0]\n if self.config.multi_piece_strategy == 'first':\n # select the first piece for multi-piece words\n offsets = token_lens_to_offsets(token_lens)\n offsets = piece_idxs.new(offsets) # batch x max_token_num\n # + 1 because the first vector is for [CLS]\n offsets = offsets.unsqueeze(-1).expand(batch_size, -1, self.bert_dim) + self.question_offset\n base_model_outputs = torch.gather(base_model_outputs, 1, offsets)\n elif self.config.multi_piece_strategy == 'average':\n # average all pieces for multi-piece words\n idxs, masks, token_num, token_len = self.token_lens_to_idxs(token_lens)\n idxs = piece_idxs.new(idxs).unsqueeze(-1).expand(batch_size, -1, self.base_model_dim) + self.question_offset\n masks = base_model_outputs.new(masks).unsqueeze(-1)\n base_model_outputs = torch.gather(base_model_outputs, 1, idxs) * masks\n base_model_outputs = base_model_outputs.view(batch_size, token_num, token_len, self.base_model_dim)\n base_model_outputs = base_model_outputs.sum(2)\n else:\n raise ValueError(f'Unknown multi-piece token handling strategy: {self.config.multi_piece_strategy}')\n base_model_outputs = self.base_model_dropout(base_model_outputs)\n return base_model_outputs\n\n def forward(self, batch):\n # process data\n enc_idxs, enc_attn, trigger_seqidxs, token_lens, token_nums = self.process_data(batch)\n \n # encoding\n base_model_outputs = self.encode(enc_idxs, enc_attn, token_lens)\n logits = self.trigger_label_ffn(base_model_outputs)\n loss = F.cross_entropy(logits.view(-1, logits.size(-1)), trigger_seqidxs.view(-1))\n \n return loss\n \n def predict(self, batch):\n self.eval()\n with torch.no_grad():\n # process data\n enc_idxs, enc_attn, _, token_lens, token_nums = self.process_data(batch)\n \n # encoding\n base_model_outputs = self.encode(enc_idxs, enc_attn, token_lens)\n logits = self.trigger_label_ffn(base_model_outputs)\n preds = logits.argmax(dim=-1)\n \n preds = preds.cpu().numpy()\n pred_triggers = []\n for pred, token_num in zip(preds, token_nums):\n pred_trigger = []\n for i, t in enumerate(pred):\n if i >= token_num:\n break\n if t == 0:\n continue\n pred_trigger.append((i, i+1, self.type_itos[\"trigger\"][t]))\n pred_triggers.append(pred_trigger)\n self.train()\n return pred_triggers" } ]

[ { "identifier": "run_snaphu", "path": "src/snaphu/_snaphu.py", "snippet": "def run_snaphu(config_file: str | os.PathLike[str]) -> None:\n \"\"\"\n Run SNAPHU with the specified config file.\n\n Parameters\n ----------\n config_file : path-like\n The file path of a text file storing configuration parameters to pass to SNAPHU.\n \"\"\"\n if not Path(config_file).is_file():\n errmsg = f\"config file not found: {config_file}\"\n raise FileNotFoundError(errmsg)\n\n with get_snaphu_executable() as snaphu:\n args = [os.fspath(snaphu), \"-f\", os.fspath(config_file)]\n try:\n subprocess.run(args, stderr=subprocess.PIPE, check=True, text=True)\n except subprocess.CalledProcessError as e:\n errmsg = e.stderr.strip()\n raise RuntimeError(errmsg) from e" }, { "identifier": "BlockIterator", "path": "src/snaphu/_util.py", "snippet": "class BlockIterator(Iterable[tuple[slice, ...]]):\n \"\"\"\n An iterable over chunks of an N-dimensional array.\n\n `BlockIterator` represents a partitioning of a multidimensional array into\n regularly-sized non-overlapping blocks. Each block is represented by an index\n expression (i.e. a tuple of `slice` objects) that can be used to access the\n corresponding block of data from the partitioned array. The full set of blocks spans\n the entire array.\n\n Iterating over a `BlockIterator` object yields each block in unspecified order.\n \"\"\"\n\n shape: tuple[int, ...]\n \"\"\"tuple of int : The shape of the array to be partitioned into blocks.\"\"\"\n chunks: tuple[int, ...]\n \"\"\"\n tuple of int : The shape of a typical block. The last block along each axis may be\n smaller.\n \"\"\"\n\n def __init__(self, shape: int | Iterable[int], chunks: int | Iterable[int]):\n \"\"\"\n Construct a new `BlockIterator` object.\n\n Parameters\n ----------\n shape : int or iterable of int\n The shape of the array to be partitioned into blocks. Each dimension must be\n > 0.\n chunks : int or iterable of int\n The shape of a typical block. Must be the same length as `shape`. Each chunk\n dimension must be > 0.\n \"\"\"\n # Normalize `shape` and `chunks` into tuples of ints.\n shape = as_tuple_of_int(shape)\n chunks = as_tuple_of_int(chunks)\n\n if len(chunks) != len(shape):\n errmsg = (\n \"size mismatch: shape and chunks must have the same number of elements,\"\n f\" instead got len(shape) != len(chunks) ({len(shape)} !=\"\n f\" {len(chunks)})\"\n )\n raise ValueError(errmsg)\n\n if not all(n > 0 for n in shape):\n errmsg = f\"shape elements must all be > 0, instead got {shape}\"\n raise ValueError(errmsg)\n if any(n <= 0 for n in chunks):\n errmsg = f\"chunk elements must all be > 0, instead got {chunks}\"\n raise ValueError(errmsg)\n\n # XXX Workaround for `frozen=True`.\n object.__setattr__(self, \"shape\", shape)\n object.__setattr__(self, \"chunks\", chunks)\n\n def __iter__(self) -> Iterator[tuple[slice, ...]]:\n \"\"\"\n Iterate over blocks in unspecified order.\n\n Yields\n ------\n block : tuple of slice\n A tuple of slices that can be used to access the corresponding block of data\n from an array.\n \"\"\"\n # Number of blocks along each array axis.\n nblocks = ceil_divide(self.shape, self.chunks)\n\n # Iterate over blocks.\n for block_ind in itertools.product(*[range(n) for n in nblocks]):\n # Get the lower & upper index bounds for the current block.\n start = np.multiply(block_ind, self.chunks)\n stop = np.minimum(start + self.chunks, self.shape)\n\n # Yield a tuple of slice objects.\n yield tuple(itertools.starmap(slice, zip(start, stop)))" }, { "identifier": "scratch_directory", "path": "src/snaphu/_util.py", "snippet": "@contextmanager\ndef scratch_directory(\n dir_: str | os.PathLike[str] | None = None, *, delete: bool = True\n) -> Generator[Path, None, None]:\n \"\"\"\n Context manager that creates a (possibly temporary) file system directory.\n\n If `dir_` is a path-like object, a directory will be created at the specified\n file system path if it did not already exist. Otherwise, if `dir_` is None, a\n temporary directory will instead be created as though by ``tempfile.mkdtemp()``.\n\n The directory may be automatically removed from the file system upon exiting the\n context manager.\n\n Parameters\n ----------\n dir_ : path-like or None, optional\n Scratch directory path. If None, a temporary directory will be created. Defaults\n to None.\n delete : bool, optional\n If True, the directory and its contents are recursively removed from the\n file system upon exiting the context manager. Defaults to True.\n\n Yields\n ------\n pathlib.Path\n Scratch directory path. If `delete` was True, the directory will be removed from\n the file system upon exiting the context manager scope.\n \"\"\"\n if dir_ is None:\n scratchdir = Path(mkdtemp())\n else:\n scratchdir = Path(dir_)\n scratchdir.mkdir(parents=True, exist_ok=True)\n\n yield scratchdir\n\n if delete:\n shutil.rmtree(scratchdir)" }, { "identifier": "InputDataset", "path": "src/snaphu/io/_dataset.py", "snippet": "class InputDataset(Protocol):\n \"\"\"\n An array-like interface for reading input datasets.\n\n `InputDataset` defines the abstract interface that types must conform to in order\n to be valid inputs to the ``snaphu.unwrap()`` function. Such objects must export\n NumPy-like `dtype`, `shape`, and `ndim` attributes and must support NumPy-style\n slice-based indexing.\n\n See Also\n --------\n OutputDataset\n \"\"\"\n\n @property\n def dtype(self) -> np.dtype:\n \"\"\"numpy.dtype : Data-type of the array's elements.\"\"\"\n\n @property\n def shape(self) -> tuple[int, ...]:\n \"\"\"tuple of int : Tuple of array dimensions.\"\"\" # noqa: D403\n\n @property\n def ndim(self) -> int:\n \"\"\"int : Number of array dimensions.\"\"\" # noqa: D403\n\n def __getitem__(self, key: slice | tuple[slice, ...], /) -> ArrayLike:\n \"\"\"Read a block of data.\"\"\"" }, { "identifier": "OutputDataset", "path": "src/snaphu/io/_dataset.py", "snippet": "class OutputDataset(Protocol):\n \"\"\"\n An array-like interface for writing output datasets.\n\n `OutputDataset` defines the abstract interface that types must conform to in order\n to be valid outputs of the ``snaphu.unwrap()`` function. Such objects must export\n NumPy-like `dtype`, `shape`, and `ndim` attributes and must support NumPy-style\n slice-based indexing.\n\n See Also\n --------\n InputDataset\n \"\"\"\n\n @property\n def dtype(self) -> np.dtype:\n \"\"\"numpy.dtype : Data-type of the array's elements.\"\"\"\n\n @property\n def shape(self) -> tuple[int, ...]:\n \"\"\"tuple of int : Tuple of array dimensions.\"\"\" # noqa: D403\n\n @property\n def ndim(self) -> int:\n \"\"\"int : Number of array dimensions.\"\"\" # noqa: D403\n\n def __setitem__(self, key: slice | tuple[slice, ...], value: np.ndarray, /) -> None:\n \"\"\"Write a block of data.\"\"\"" } ]

[ { "identifier": "WeightsDownloader", "path": "weights_downloader.py", "snippet": "class WeightsDownloader:\n @staticmethod\n def download_if_not_exists(url, dest):\n if not os.path.exists(dest):\n WeightsDownloader.download(url, dest)\n\n @staticmethod\n def download(url, dest):\n start = time.time()\n print(\"downloading url: \", url)\n print(\"downloading to: \", dest)\n subprocess.check_call([\"pget\", \"-x\", url, dest], close_fds=False)\n print(\"downloading took: \", time.time() - start)" }, { "identifier": "WeightsManager", "path": "weights_manager.py", "snippet": "class WeightsManager:\n def __init__(self, predictor):\n self.predictor = predictor\n self.weights_cache = WeightsDownloadCache()\n\n def load_trained_weights(self, weights, pipe):\n from no_init import no_init_or_tensor\n\n # weights can be a URLPath, which behaves in unexpected ways\n weights = str(weights)\n if self.predictor.tuned_weights == weights:\n print(\"skipping loading .. weights already loaded\")\n return\n\n self.predictor.tuned_weights = weights\n\n local_weights_cache = self.weights_cache.ensure(weights)\n\n # load UNET\n print(\"Loading fine-tuned model\")\n self.predictor.is_lora = False\n\n maybe_unet_path = os.path.join(local_weights_cache, \"unet.safetensors\")\n if not os.path.exists(maybe_unet_path):\n print(\"Does not have Unet. assume we are using LoRA\")\n self.predictor.is_lora = True\n\n if not self.predictor.is_lora:\n print(\"Loading Unet\")\n\n new_unet_params = load_file(\n os.path.join(local_weights_cache, \"unet.safetensors\")\n )\n # this should return _IncompatibleKeys(missing_keys=[...], unexpected_keys=[])\n pipe.unet.load_state_dict(new_unet_params, strict=False)\n\n else:\n print(\"Loading Unet LoRA\")\n\n unet = pipe.unet\n\n tensors = load_file(os.path.join(local_weights_cache, \"lora.safetensors\"))\n\n unet_lora_attn_procs = {}\n name_rank_map = {}\n for tk, tv in tensors.items():\n # up is N, d\n if tk.endswith(\"up.weight\"):\n proc_name = \".\".join(tk.split(\".\")[:-3])\n r = tv.shape[1]\n name_rank_map[proc_name] = r\n\n for name, attn_processor in unet.attn_processors.items():\n cross_attention_dim = (\n None\n if name.endswith(\"attn1.processor\")\n else unet.config.cross_attention_dim\n )\n if name.startswith(\"mid_block\"):\n hidden_size = unet.config.block_out_channels[-1]\n elif name.startswith(\"up_blocks\"):\n block_id = int(name[len(\"up_blocks.\")])\n hidden_size = list(reversed(unet.config.block_out_channels))[\n block_id\n ]\n elif name.startswith(\"down_blocks\"):\n block_id = int(name[len(\"down_blocks.\")])\n hidden_size = unet.config.block_out_channels[block_id]\n with no_init_or_tensor():\n module = LoRAAttnProcessor2_0(\n hidden_size=hidden_size,\n cross_attention_dim=cross_attention_dim,\n rank=name_rank_map[name],\n )\n unet_lora_attn_procs[name] = module.to(\"cuda\", non_blocking=True)\n\n unet.set_attn_processor(unet_lora_attn_procs)\n unet.load_state_dict(tensors, strict=False)\n\n # load text\n handler = TokenEmbeddingsHandler(\n [pipe.text_encoder, pipe.text_encoder_2], [pipe.tokenizer, pipe.tokenizer_2]\n )\n handler.load_embeddings(os.path.join(local_weights_cache, \"embeddings.pti\"))\n\n # load params\n with open(os.path.join(local_weights_cache, \"special_params.json\"), \"r\") as f:\n params = json.load(f)\n self.predictor.token_map = params\n\n self.predictor.tuned_model = True" }, { "identifier": "ControlNet", "path": "controlnet.py", "snippet": "class ControlNet:\n CONTROLNET_MODELS = [\n \"none\",\n \"edge_canny\",\n \"illusion\",\n \"depth_leres\",\n \"depth_midas\",\n \"soft_edge_pidi\",\n \"soft_edge_hed\",\n \"lineart\",\n \"lineart_anime\",\n \"openpose\",\n # Preprocessors without an XL model yet\n # \"straight_edge_mlsd\",\n # \"face_detector\",\n # \"content_shuffle\",\n # \"normal_bae\",\n # \"segementation_sam\",\n ]\n\n def __init__(self, predictor):\n WeightsDownloader.download_if_not_exists(CONTROLNET_URL, CONTROLNET_MODEL_CACHE)\n self.predictor = predictor\n self.controlnet_preprocessor = None\n self.models = {}\n\n def initialize_controlnet(self, model_name):\n print(\"Initializing\", model_name)\n return ControlNetModel.from_pretrained(\n model_name, cache_dir=CONTROLNET_MODEL_CACHE, torch_dtype=torch.float16\n )\n\n def get_model(self, controlnet_name):\n if controlnet_name not in self.models:\n if controlnet_name.startswith(\"edge_\"):\n self.models[controlnet_name] = self.initialize_controlnet(\"diffusers/controlnet-canny-sdxl-1.0\")\n elif controlnet_name.startswith(\"depth_\"):\n self.models[controlnet_name] = self.initialize_controlnet(\"diffusers/controlnet-depth-sdxl-1.0-small\")\n elif controlnet_name.startswith(\"soft_edge\") or controlnet_name.startswith(\"lineart\"):\n self.models[controlnet_name] = self.initialize_controlnet(\"SargeZT/controlnet-sd-xl-1.0-softedge-dexined\")\n elif controlnet_name == \"openpose\":\n self.models[controlnet_name] = self.initialize_controlnet(\"thibaud/controlnet-openpose-sdxl-1.0\")\n elif controlnet_name == \"illusion\":\n self.models[controlnet_name] = self.initialize_controlnet(\"monster-labs/control_v1p_sdxl_qrcode_monster\")\n return self.models.get(controlnet_name)\n\n def get_models(self, controlnet_names):\n models = [\n self.get_model(controlnet_name) for controlnet_name in controlnet_names\n ]\n return list(filter(None, models))\n\n def preprocess(self, image, controlnet_name):\n # Illusion model needs no preprocessing\n if controlnet_name == \"illusion\" or controlnet_name == \"none\":\n return image\n\n if self.controlnet_preprocessor is None:\n self.controlnet_preprocessor = ControlNetPreprocessor(self.predictor)\n\n return self.controlnet_preprocessor.process_image(image, controlnet_name)\n\n @staticmethod\n def get_controlnet_names():\n return ControlNet.CONTROLNET_MODELS" }, { "identifier": "SizingStrategy", "path": "sizing_strategy.py", "snippet": "class SizingStrategy:\n def __init__(self):\n pass\n\n def get_dimensions(self, image):\n original_width, original_height = image.size\n print(\n f\"Original dimensions: Width: {original_width}, Height: {original_height}\"\n )\n resized_width, resized_height = self.get_resized_dimensions(\n original_width, original_height\n )\n print(\n f\"Dimensions to resize to: Width: {resized_width}, Height: {resized_height}\"\n )\n return resized_width, resized_height\n\n def get_allowed_dimensions(self, base=LOWEST_DIMENSION, max_dim=MAX_DIMENSION):\n \"\"\"\n Function to generate allowed dimensions optimized around a base up to a max\n \"\"\"\n allowed_dimensions = []\n for i in range(base, max_dim + 1, 64):\n for j in range(base, max_dim + 1, 64):\n allowed_dimensions.append((i, j))\n return allowed_dimensions\n\n def get_resized_dimensions(self, width, height):\n allowed_dimensions = self.get_allowed_dimensions()\n aspect_ratio = width / height\n print(f\"Aspect Ratio: {aspect_ratio:.2f}\")\n # Find the closest allowed dimensions that maintain the aspect ratio\n # and are closest to the optimum dimension\n closest_dimensions = min(\n allowed_dimensions,\n key=lambda dim: abs(dim[0] / dim[1] - aspect_ratio)\n + abs(dim[0] - OPTIMUM_DIMENSION),\n )\n return closest_dimensions\n\n def resize_images(self, images, width, height):\n return [\n img.resize((width, height)) if img is not None else None for img in images\n ]\n\n def open_image(self, image_path):\n return Image.open(str(image_path)) if image_path is not None else None\n\n def apply(\n self,\n sizing_strategy,\n width,\n height,\n image=None,\n mask=None,\n control_1_image=None,\n control_2_image=None,\n control_3_image=None,\n ):\n image_keys = [\n \"input_image\",\n \"mask_image\",\n \"controlnet_1_image\",\n \"controlnet_2_image\",\n \"controlnet_3_image\",\n ]\n image_values = [image, mask, control_1_image, control_2_image, control_3_image]\n image_dict = {\n key: self.open_image(value).convert(\"RGB\") if value is not None else None\n for key, value in zip(image_keys, image_values)\n }\n\n if sizing_strategy in image_dict:\n print(f\"Resizing based on {sizing_strategy}\")\n width, height = self.get_dimensions(image_dict[sizing_strategy])\n else:\n print(\"Using given dimensions\")\n\n resized_images = self.resize_images(\n list(image_dict.values()),\n width,\n height,\n )\n\n return width, height, resized_images" } ]

[ { "identifier": "apply_crop", "path": "utils/array_operations.py", "snippet": "def apply_crop(array, crop):\n return array[crop[0]:crop[0] + crop[2], crop[1]:crop[1] + crop[3]]" }, { "identifier": "get_color_aug_fn", "path": "utils/augmentation.py", "snippet": "def get_color_aug_fn(params):\n fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = params\n def color_aug_fn(img):\n for fn_id in fn_idx:\n if fn_id == 0 and brightness_factor is not None:\n img = F.adjust_brightness(img, brightness_factor)\n elif fn_id == 1 and contrast_factor is not None:\n img = F.adjust_contrast(img, contrast_factor)\n elif fn_id == 2 and saturation_factor is not None:\n img = F.adjust_saturation(img, saturation_factor)\n elif fn_id == 3 and hue_factor is not None:\n img = F.adjust_hue(img, hue_factor)\n\n return img\n\n return color_aug_fn" } ]

[ { "identifier": "FCBlock", "path": "watermarking_model/model/blocks.py", "snippet": "class FCBlock(nn.Module):\n \"\"\" Fully Connected Block \"\"\"\n\n def __init__(self, in_features, out_features, activation=None, bias=False, dropout=None, spectral_norm=False):\n super(FCBlock, self).__init__()\n self.fc_layer = nn.Sequential()\n self.fc_layer.add_module(\n \"fc_layer\",\n LinearNorm(\n in_features,\n out_features,\n bias,\n spectral_norm,\n ),\n )\n if activation is not None:\n self.fc_layer.add_module(\"activ\", activation)\n self.dropout = dropout\n\n def forward(self, x):\n x = self.fc_layer(x)\n if self.dropout is not None:\n x = F.dropout(x, self.dropout, self.training)\n return x" }, { "identifier": "PositionalEncoding", "path": "watermarking_model/model/blocks.py", "snippet": "class PositionalEncoding(nn.Module):\n def __init__(self, d_model, dropout=0.0, max_len=10000):\n super(PositionalEncoding, self).__init__()\n self.dropout = nn.Dropout(p=dropout)\n\n pe = torch.zeros(max_len, d_model)\n position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))\n pe[:, 0::2] = torch.sin(position * div_term)\n pe[:, 1::2] = torch.cos(position * div_term)\n # pe = pe.unsqueeze(0).transpose(0, 1)\n self.register_buffer('pe', pe)\n\n def forward(self, x):\n x = x + self.pe[:x.size(1), :] # [WORD_NUM, BATCH, DIM]\n return self.dropout(x)" }, { "identifier": "Mish", "path": "watermarking_model/model/blocks.py", "snippet": "class Mish(nn.Module):\n def forward(self, x):\n return x * torch.tanh(F.softplus(x))" }, { "identifier": "Conv1DBlock", "path": "watermarking_model/model/blocks.py", "snippet": "class Conv1DBlock(nn.Module):\n \"\"\" 1D Convolutional Block \"\"\"\n\n def __init__(self, in_channels, out_channels, kernel_size, activation=None, dropout=None, spectral_norm=False):\n super(Conv1DBlock, self).__init__()\n\n self.conv_layer = nn.Sequential()\n self.conv_layer.add_module(\n \"conv_layer\",\n ConvNorm(\n in_channels,\n out_channels,\n kernel_size=kernel_size,\n stride=1,\n padding=int((kernel_size - 1) / 2),\n dilation=1,\n w_init_gain=\"tanh\",\n spectral_norm=spectral_norm,\n ),\n )\n if activation is not None:\n self.conv_layer.add_module(\"activ\", activation)\n self.dropout = dropout\n\n def forward(self, x, mask=None):\n # x = x.contiguous().transpose(1, 2)\n x = self.conv_layer(x)\n\n if self.dropout is not None:\n x = F.dropout(x, self.dropout, self.training)\n\n # x = x.contiguous().transpose(1, 2)\n if mask is not None:\n x = x.masked_fill(mask.unsqueeze(-1), 0)\n\n return x" } ]

[ { "identifier": "AssistantConfig", "path": "user_config.py", "snippet": "class AssistantConfig:\n def __init__(self, tools_to_use=None):\n self.tools_to_use = tools_to_use or []\n self.instructions_for_assistant = 'Use the tools to accomplish the task'\n self.files_for_assistant = [] # Local file paths\n self.assistant_details = self._build_assistant_details()\n\n def _build_assistant_details(self):\n assistant_details = {\n 'build_params': {\n 'model': \"gpt-4-1106-preview\",\n 'name': \"Tool User\",\n 'description': \"Assistant to use tools made by the tool creator.\",\n 'instructions': self.instructions_for_assistant,\n 'tools': [{\"type\": \"code_interpreter\"}], # Tools will be added in the loop below\n 'file_ids': [],\n 'metadata': {},\n },\n 'file_paths': self.files_for_assistant,\n 'functions': {}, # Functions will be added in the loop below\n }\n\n # Load tools and their details\n os.makedirs('tools', exist_ok=True)\n if not self.tools_to_use:\n self.tools_to_use = [tool.split('.')[0] for tool in os.listdir('tools') if tool.endswith('.py')]\n for tool in self.tools_to_use:\n with open(f'tools/{tool}.json') as f:\n tool_details = json.load(f)\n\n with open(f'tools/{tool}.py') as f:\n tool_code = f.read()\n\n assistant_details['build_params']['tools'].append({\n \"type\": \"function\",\n \"function\": {\n \"name\": tool_details['name'],\n \"description\": tool_details['description'],\n \"parameters\": eval(tool_details['parameters']),\n },\n })\n assistant_details['functions'][tool_details['name']] = tool_code\n assistant_details['dependencies'] = assistant_details.get('dependencies', []) + tool_details['dependencies'].split()\n\n return assistant_details" }, { "identifier": "chat", "path": "utils.py", "snippet": "def chat(client, thread, assistant, functions):\n while True:\n user_message = input(\"You: \")\n\n # add user message to thread\n thread_message = client.beta.threads.messages.create(\n thread.id,\n role=\"user\",\n content=user_message,\n ) \n\n # get assistant response in thread\n run = client.beta.threads.runs.create(\n thread_id=thread.id,\n assistant_id=assistant.id,\n )\n\n # wait for run to complete\n wait_time = 0\n while True:\n run = client.beta.threads.runs.retrieve(\n thread_id=thread.id,\n run_id=run.id,\n )\n\n if run.status == \"completed\":\n break\n elif run.status == \"in_progress\":\n continue\n elif run.status == \"queued\":\n continue\n elif run.status == \"requires_action\":\n if run.required_action.type == 'submit_tool_outputs':\n tool_calls = run.required_action.submit_tool_outputs.tool_calls\n\n tool_outputs = []\n for tc in tool_calls:\n function_to_call = functions.get(tc.function.name)\n if not function_to_call:\n raise ValueError(f\"Function {tc.function.name} not found in execution environment\")\n\n # safely parse function arguments and call function\n try:\n function_args = json.loads(tc.function.arguments or {})\n function_response = function_to_call(**function_args)\n except Exception as e:\n exception_message = f\"Exception in function {tc.function.name}: {e}\"\n print(exception_message, flush=True)\n function_response = exception_message\n\n print(f\"\\nCalling function {tc.function.name} with args {function_args}\", flush=True)\n tool_outputs.append({\n \"tool_call_id\": tc.id,\n \"output\": json.dumps(function_response, default=numpy_json_serializer),\n })\n\n print(f\"Submitting tool outputs\\n {json.dumps(tool_outputs,indent=4)}\\n\\n\", flush=True)\n run = client.beta.threads.runs.submit_tool_outputs(\n thread_id=thread.id,\n run_id=run.id,\n tool_outputs=tool_outputs\n )\n else:\n input(f'Run status: {run.status}. press enter to continue, or ctrl+c to quit')\n\n if wait_time % 5 == 0:\n print(f\"waiting for run to complete...\", flush=True)\n wait_time += 1\n time.sleep(1)\n\n\n # get most recent message from thread\n thread_message = client.beta.threads.messages.list(thread.id, limit=1, order='desc').data[0]\n\n # get assistant response from message\n try:\n assistant_response = ''\n for content in thread_message.content:\n if content.type == 'text':\n assistant_response += content.text.value\n elif content.type == 'image_file':\n # get the file id\n file_id = content.image_file.file_id\n message_file = client.beta.threads.messages.files.retrieve(\n thread_id=thread.id,\n message_id=thread_message.id,\n file_id=file_id,\n )\n\n # get the image data\n image_data = client.files.retrieve_content(message_file.id)\n image_data_bytes = image_data.data\n \n # # debug output\n # print(f\"File id: {file_id}\", flush=True)\n # print(f'Message file: {message_file}\\n\\n{dir(message_file)}', flush=True)\n # print(f\"Image data: {image_data}\\n\\n{dir(image_data)}\", flush=True)\n # print(f\"Image data bytes: {image_data_bytes}\", flush=True)\n\n os.makedirs('images', exist_ok=True)\n with open(f\"images/{file_id}.png\", \"wb\") as file:\n file.write(image_data_bytes)\n print(f\"Saved image to images/{file_id}.png\", flush=True)\n\n assistant_response += f\"\\n\"\n assistant_response += '\\n'\n\n except Exception as e:\n print(f\"Exception getting assistant response: {e}\", flush=True)\n\n\n print(f\"\\n\\nBot: {assistant_response}\\n\\n\", flush=True)\n\n # continue?\n try:\n input(\"Press enter to continue chatting, or ctrl+c to stop chat\\n\")\n except KeyboardInterrupt:\n print(f\"Stopping chat\\n\" + 90*\"-\" + \"\\n\\n\", flush=True)\n break\n\n # Store information about the conversation\n thread_creation_time = time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime(thread.created_at))\n conversation = {\n 'start_date': thread_creation_time, \n 'end_date': time.strftime(\"%Y-%m-%d %H:%M:%S\", time.localtime()),\n 'assistant': assistant.name, \n 'bot_id': assistant.id,\n 'thread_id': thread.id,\n }\n\n # Check that chat_history.json exists and append the conversation\n chat_history_path = Path('assistants/chat_history.json')\n chat_history = []\n\n if chat_history_path.exists():\n with chat_history_path.open('r+') as f:\n try:\n chat_history = json.load(f)\n except JSONDecodeError:\n pass # File is empty or invalid, will overwrite with new content\n\n chat_history.append(conversation)\n\n with chat_history_path.open('w') as f:\n json.dump(chat_history, f, indent=4)" } ]

[ { "identifier": "add", "path": "src/tinysig/utils.py", "snippet": "def add(values: list[int], size: int) -> int:\ndef add_ec(points: list[EccPoint]) -> int:\ndef generate_additive_shares(secret: int, n: int, size: int) -> list[int]:\ndef multiply(values: list[int], size: int) -> int:\ndef egcd(a: int, p: int) -> int:\ndef hash(message: str, q: int):\ndef verify_dsa_signature(message: int, r: int, s: int, y: int, p: int, q: int, g: int) -> None:\ndef verify_ecdsa_signature(message: int, r: int, s: int, Y: EccPoint, q: int, G: EccPoint) -> None:\n def __init__(self, message):\n def setUp(self): \n def test_add(self):\n def test_generate_additive_shares(self):\n def test_multiply(self):\n V = u1 * G + u2 * Y\nclass VerifySignatureError(Exception):\nclass TestUtils(unittest.TestCase):" }, { "identifier": "DSASetup", "path": "src/tinysig/setup.py", "snippet": "class DSASetup:\n \"\"\"\n Dataclass representing a DSA (Digital Signature Algorithm) setup.\n\n Example:\n setup = DSASetup.generate_dsa_setup()\n \"\"\"\n\n p: int\n \"\"\"The DSA modulus.\"\"\"\n q: int\n \"\"\"The order of the subgroup.\"\"\"\n g: int\n \"\"\"A generator of the subgroup.\"\"\"\n h: int\n \"\"\"A generator of the field :math:`\\mathbb{Z}_q`.\"\"\"\n\n def generate_dsa_setup():\n \"\"\"Generate a DSA setup based on system parameters.\"\"\"\n key = DSA.generate(2048)\n g = int(key._key['g'])\n p = int(key._key['p'])\n q = int(key._key['q']) \n h = get_generator(q)\n return DSASetup(p, q, g, h)" }, { "identifier": "ECDSASetup", "path": "src/tinysig/setup.py", "snippet": "class ECDSASetup:\n \"\"\"\n Dataclass representing an ECDSA (Elliptic Curve Digital Signature Algorithm) setup.\n\n Example:\n setup = ECDSASetup.generate_ecdsa_setup()\n \"\"\"\n\n curve: str\n \"\"\"The name of the elliptic curve.\"\"\"\n p: Optional[int] = None\n \"\"\"The finite field of the elliptic curve.\"\"\"\n q: Optional[int] = None\n \"\"\"The order of the elliptic curve group.\"\"\"\n G: Optional[EccPoint] = None\n \"\"\"A base point on the elliptic curve.\"\"\"\n h: Optional[int] = None\n \"\"\"A generator of field :math:`\\mathbb{Z}_q`.\"\"\"\n\n def generate_ecdsa_setup(self):\n \"\"\"\n Generate an ECDSA setup for the specified elliptic curve.\n\n Returns:\n ECDSASetup: An instance of ECDSASetup with generated parameters.\n\n Raises:\n ValueError: If the specified curve is not supported.\n\n Example:\n >>> setup = ECDSASetup(curve='P-256').generate_ecdsa_setup()\n \"\"\"\n\n supported_curves = self.supported_curves()\n curve = self.curve\n if curve not in supported_curves:\n raise ValueError(\"{} is not one of the specified curves. \\\n Please choose one of the following curves:\\n \\\n ['P-192', 'P-224', 'P-256', 'P-384', 'P-521']\".format(curve))\n p = int(ECC._curves[curve].p)\n q = int(ECC._curves[curve].order)\n G = ECC._curves[curve].G\n h = get_generator(int(q))\n return ECDSASetup(curve, p, q, G, h)\n \n @staticmethod\n def supported_curves():\n \"\"\"\n Get a list of supported elliptic curves.\n\n Returns:\n List[str]: A list of supported elliptic curve names.\n\n Example:\n >>> supported_curves = ECDSASetup.supported_curves()\n >>> print(supported_curves)\n ['P-192', 'P-224', 'P-256', 'P-384', 'P-521']\n \"\"\"\n \n return ['P-192', 'P-224', 'P-256', 'P-384', 'P-521']\n \n def print_supported_curves(self):\n \"\"\"\n Print the list of supported elliptic curves.\n \"\"\"\n\n supported_curves = self.supported_curves()\n print(\"Supported Elliptic Curves: \", supported_curves)" }, { "identifier": "Network", "path": "src/tinysig/network.py", "snippet": "class Network:\n \"\"\"Represents a network of nodes and clients.\n \n Manages the interactions and cryptographic operations within the network, \n including sharing secrets, broadcasting values, and reconstructing shared values.\n \"\"\"\n\n nodes: List[Node]\n \"\"\"List of nodes in the network.\"\"\"\n clients: List[Client]\n \"\"\"List of clients in the network.\"\"\"\n q: int\n \"\"\"Prime field.\"\"\"\n h: int \n \"\"\"Multiplicative field generator.\"\"\"\n\n def __init__(self, N, q, h=2, C=1):\n \"\"\"\n Initialize the network with 'N' nodes, prime field 'q', field generator 'h', and 'C' clients.\n \n Parameters:\n N (int): Number of nodes in the network.\n q (int): Prime field.\n h (int): Multiplicative field generator (default is 2).\n C (int): Number of clients in the network (default is 1).\n \"\"\"\n self.nodes = [Node(i+1) for i in range(N)]\n self.clients = [Client(i+1) for i in range(C)]\n self.N = N\n self.q = q\n self.h = h\n\n def print(self):\n \"\"\"Print a readable representation of the network, including nodes and clients with their databases.\"\"\"\n print(f\"Network(N={len(self.nodes)}, q={self.q},\")\n print(\" nodes=[\")\n for node in self.nodes:\n print(f\" Node(id={node.id},\")\n print(\" shares_db={\")\n for key, value in node.shares_db.items():\n print(f\" {key}: {value},\")\n print(\" },\")\n print(\" public_keys={\")\n for key, value in node.he_public_keys.items():\n print(f\" {key}: {value},\")\n print(\" },\")\n print(\" open_db={\")\n for key, value in node.open_db.items():\n print(f\" {key}: {value},\")\n print(\" }\")\n print(\" )\")\n print(\" ]\\n)\")\n print(\" clients=[\")\n for client in self.clients:\n print(f\" Client(id={client.id},\")\n print(\" shares_db={\")\n for key, value in client.shares_db.items():\n print(f\" {key}: {value},\")\n print(\" },\")\n print(\" public_keys={\")\n for key, value in client.he_public_keys.items():\n print(f\" {key}: {value},\")\n print(\" },\")\n print(f\" private_keys={client.he_private_key},\")\n print(\" open_db={\")\n for key, value in client.open_db.items():\n print(f\" {key}: {value},\")\n print(\" }\")\n print(\" )\")\n print(\" ]\\n)\")\n\n def reconstruct_local(self, type_share: str, get_label: str, save_label: str, party: Union[Client, Node]) -> None:\n \"\"\"Locally reconstruct exponent share ('exp') or base ('base') shared value.\"\"\"\n \n type_label = \"_sh_exp\" if type_share == \"exp\" else \"_sh_base\"\n p = (self.q - 1) if type_share == \"exp\" else self.q\n shares = [party.get_share(get_label+type_label+\"_node_\"+str(node.id)) for node in self.nodes]\n reconstructed = add(shares, p)\n party.set_share(reconstructed, save_label)\n\n def broadcast(self, element: int, label: str) -> None:\n \"\"\"Send element to all nodes.\"\"\"\n\n for node in self.nodes:\n node.open_db[label] = element\n\n def send(self, type_share: str, label: str, party: Union[Client, Node], delete=False) -> None:\n \"\"\"Send exponent ('exp') or base ('base') share to party.\"\"\"\n \n type_label = \"_sh_exp\" if type_share == \"exp\" else \"_sh_base\"\n for node in self.nodes:\n sh_node = node.get_share(label+type_label)\n sh_label = label+type_label+\"_node_\"+str(node.id)\n party.set_share(sh_node, sh_label)\n node.delete_share(label+type_label) if delete else None\n\n def share(self, secret: int, size: int, label: str) -> None:\n \"\"\"Share secret value with all\"\"\"\n\n shares = generate_additive_shares(secret, self.N, size)\n for node in self.nodes:\n node.set_share(shares[node.id - 1], label)\n\n def reveal(self, type_share: str, get_label: str, save_label: str, party: Union[Client, Node]) -> None:\n \"\"\"Send exponent ('exp') or base ('base') share to party.\"\"\" \n \n self.send(type_share, get_label, party)\n self.reconstruct_local(type_share, get_label, save_label, party)" }, { "identifier": "Client", "path": "src/tinysig/network.py", "snippet": "class Client(Node):\n \"\"\"Represents a client node in the network, inheriting from the 'Node' class.\"\"\"\n he_private_key: int = field(default=0)" } ]

[ { "identifier": "Activation", "path": "src/physicsml/models/mace/modules/_activation.py", "snippet": "class Activation(torch.nn.Module):\n r\"\"\"Scalar activation function.\n\n Odd scalar inputs require activation functions with a defined parity (odd or even).\n\n Parameters\n ----------\n irreps_in : `e3nn.o3.Irreps`\n representation of the input\n\n acts : list of function or None\n list of activation functions, `None` if non-scalar or identity\n\n Examples\n --------\n\n >>> a = Activation(\"256x0o\", [torch.abs])\n >>> a.irreps_out\n 256x0e\n\n >>> a = Activation(\"256x0o+16x1e\", [None, None])\n >>> a.irreps_out\n 256x0o+16x1e\n \"\"\"\n\n def __init__(self, irreps_in: o3.Irreps, acts: List[Optional[torch.nn.Module]]):\n super().__init__()\n irreps_in = o3.Irreps(irreps_in)\n if len(irreps_in) != len(acts):\n raise ValueError(\n f\"Irreps in and number of activation functions does not match: {len(acts), (irreps_in, acts)}\",\n )\n\n # normalize the second moment\n acts = [normalize2mom(act) if act is not None else None for act in acts]\n\n from e3nn.util._argtools import _get_device\n\n irreps_out = []\n for (mul, (l_in, p_in)), act in zip(irreps_in, acts):\n if act is not None:\n if l_in != 0:\n raise ValueError(\n \"Activation: cannot apply an activation function to a non-scalar input.\",\n )\n\n x = torch.linspace(0, 10, 256, device=_get_device(act))\n\n a1, a2 = act(x), act(-x)\n if (a1 - a2).abs().max() < 1e-5:\n p_act = 1\n elif (a1 + a2).abs().max() < 1e-5:\n p_act = -1\n else:\n p_act = 0\n\n p_out = p_act if p_in == -1 else p_in\n irreps_out.append((mul, (0, p_out)))\n\n if p_out == 0:\n raise ValueError(\n \"Activation: the parity is violated! The input scalar is odd but the activation is neither \"\n \"even nor odd.\",\n )\n else:\n irreps_out.append((mul, (l_in, p_in)))\n\n self.irreps_in = irreps_in\n self.irreps_out = o3.Irreps(irreps_out)\n self.acts = torch.nn.ModuleList(acts) # type: ignore\n assert len(self.irreps_in) == len(self.acts)\n\n self.ir_dims: List[int] = [ir.dim for _, ir in self.irreps_in]\n\n def __repr__(self) -> str:\n acts = \"\".join([\"x\" if a is not None else \" \" for a in self.acts])\n return f\"{self.__class__.__name__} [{acts}] ({self.irreps_in} -> {self.irreps_out})\"\n\n def forward(self, features: torch.Tensor, dim: int = -1) -> torch.Tensor:\n \"\"\"evaluate\n\n Parameters\n ----------\n features : `torch.Tensor`\n tensor of shape ``(...)``\n\n Returns\n -------\n `torch.Tensor`\n tensor of shape the same shape as the input\n \"\"\"\n # - PROFILER - with torch.autograd.profiler.record_function(repr(self)):\n output = []\n index = 0\n\n for i, act in enumerate(self.acts):\n ir_dim = self.ir_dims[i]\n mul, ir = self.irreps_in[i]\n\n if act is not None:\n output.append(act(features.narrow(dim, index, mul)))\n else:\n output.append(features.narrow(dim, index, mul * ir_dim))\n index += mul * ir_dim\n\n if len(output) > 1:\n return torch.cat(output, dim=dim)\n elif len(output) == 1:\n out: torch.Tensor = output[0]\n return out\n else:\n return torch.zeros_like(features)" }, { "identifier": "reshape_irreps", "path": "src/physicsml/models/mace/modules/irreps_tools.py", "snippet": "class reshape_irreps(torch.nn.Module):\n def __init__(self, irreps: o3.Irreps) -> None:\n super().__init__()\n self.irreps = o3.Irreps(irreps)\n self.dims = []\n self.muls = []\n for mul, ir in self.irreps:\n d = ir.dim\n self.dims.append(d)\n self.muls.append(mul)\n\n def forward(self, tensor: torch.Tensor) -> torch.Tensor:\n ix = 0\n out = []\n batch, _ = tensor.shape\n for mul, d in zip(self.muls, self.dims):\n field = tensor[:, ix : ix + mul * d] # [batch, sample, mul * repr]\n ix += mul * d\n field = field.reshape(batch, mul, d)\n out.append(field)\n return torch.cat(out, dim=-1)" }, { "identifier": "tp_out_irreps_with_instructions", "path": "src/physicsml/models/mace/modules/irreps_tools.py", "snippet": "def tp_out_irreps_with_instructions(\n irreps1: o3.Irreps,\n irreps2: o3.Irreps,\n target_irreps: o3.Irreps,\n) -> Tuple[o3.Irreps, List]:\n trainable = True\n\n # Collect possible irreps and their instructions\n irreps_out_list: List[Tuple[int, o3.Irreps]] = []\n instructions = []\n for i, (mul, ir_in) in enumerate(irreps1):\n for j, (_, ir_edge) in enumerate(irreps2):\n for ir_out in ir_in * ir_edge: # | l1 - l2 | <= l <= l1 + l2\n if ir_out in target_irreps:\n k = len(irreps_out_list) # instruction index\n irreps_out_list.append((mul, ir_out))\n instructions.append((i, j, k, \"uvu\", trainable))\n\n # We sort the output irreps of the tensor product so that we can simplify them\n # when they are provided to the second o3.Linear\n irreps_out = o3.Irreps(irreps_out_list)\n irreps_out, permut, _ = irreps_out.sort()\n\n # Permute the output indexes of the instructions to match the sorted irreps:\n instructions = [\n (i_in1, i_in2, permut[i_out], mode, train)\n for i_in1, i_in2, i_out, mode, train in instructions\n ]\n\n return irreps_out, instructions" }, { "identifier": "BesselBasis", "path": "src/physicsml/models/mace/modules/radial.py", "snippet": "class BesselBasis(torch.nn.Module):\n def __init__(\n self,\n r_max: float,\n num_basis: int = 8,\n trainable: bool = False,\n ) -> None:\n super().__init__()\n\n bessel_weights = torch.pi * torch.arange(1, num_basis + 1) / r_max\n\n if trainable:\n self.bessel_weights = torch.nn.Parameter(bessel_weights)\n else:\n self.register_buffer(\"bessel_weights\", bessel_weights)\n\n self.r_max = r_max\n self.prefactor = sqrt(2.0 / r_max)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor: # [..., 1]\n bessel_funcs = self.prefactor * (\n torch.sin(self.bessel_weights * x) / x\n ) # [..., num_basis]\n return bessel_funcs" }, { "identifier": "PolynomialCutoff", "path": "src/physicsml/models/mace/modules/radial.py", "snippet": "class PolynomialCutoff(torch.nn.Module):\n def __init__(self, r_max: float, p: int = 6) -> None:\n super().__init__()\n\n self.r_max = r_max\n self.p = p\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n envelope = (\n 1.0\n - ((self.p + 1.0) * (self.p + 2.0) / 2.0)\n * torch.pow(x / self.r_max, self.p)\n + self.p * (self.p + 2.0) * torch.pow(x / self.r_max, self.p + 1)\n - (self.p * (self.p + 1.0) / 2) * torch.pow(x / self.r_max, self.p + 2)\n )\n\n poly: torch.Tensor = envelope * (x < self.r_max)\n return poly" }, { "identifier": "SymmetricContraction", "path": "src/physicsml/models/mace/modules/symmetric_contraction.py", "snippet": "class SymmetricContraction(CodeGenMixin, torch.nn.Module):\n def __init__(\n self,\n irreps_in: o3.Irreps,\n irreps_out: o3.Irreps,\n correlation: Union[int, Dict[str, int]],\n irrep_normalization: Literal[\"component\", \"norm\"] = \"component\",\n path_normalization: Literal[\"element\", \"path\"] = \"element\",\n internal_weights: Optional[bool] = None,\n shared_weights: Optional[torch.Tensor] = None,\n num_elements: Optional[int] = None,\n ) -> None:\n super().__init__()\n\n assert irrep_normalization in [\"component\", \"norm\", \"none\"]\n assert path_normalization in [\"element\", \"path\", \"none\"]\n\n self.irreps_in = o3.Irreps(irreps_in)\n self.irreps_out = o3.Irreps(irreps_out)\n\n del irreps_in, irreps_out\n\n if not isinstance(correlation, dict):\n corr = correlation\n correlation = {}\n for irrep_out in self.irreps_out:\n correlation[irrep_out] = corr\n\n assert shared_weights or not internal_weights\n\n if internal_weights is None:\n internal_weights = True\n\n self.internal_weights = internal_weights\n self.shared_weights = shared_weights\n\n del internal_weights, shared_weights\n\n self.contractions = torch.nn.ModuleList()\n for irrep_out in self.irreps_out:\n self.contractions.append(\n Contraction(\n irreps_in=self.irreps_in,\n irrep_out=o3.Irreps(str(irrep_out.ir)),\n correlation=correlation[irrep_out],\n internal_weights=self.internal_weights,\n num_elements=num_elements,\n weights=self.shared_weights,\n ),\n )\n\n def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n outs = [contraction(x, y) for contraction in self.contractions]\n return torch.cat(outs, dim=-1)" } ]

[ { "identifier": "misc", "path": "utils/misc.py", "snippet": "def get_node_rank():\ndef get_local_rank():\ndef is_rank_zero():\ndef cpu_count():\ndef get_file(dataset_path, prefix, postfix, ext):\ndef is_otor(task_name, or_oracle=False, oracle=False):" }, { "identifier": "AVAILABLE_TASKS", "path": "utils/constants.py", "snippet": "AVAILABLE_TASKS = {\n DecoderTypes.TRANSFORMER: {\n Tasks.OCR_READ,\n Tasks.TEXT_READ,\n Tasks.DONUT_KIE,\n Tasks.OCR_READ_2HEAD,\n Tasks.OCR_READ_TEXTINSTANCEPADDING,\n Tasks.TABLE_PARSING,\n Tasks.OTOR,\n Tasks.OTOR_ORACLE,\n },\n}" }, { "identifier": "DecoderTypes", "path": "utils/constants.py", "snippet": "class DecoderTypes:\n TRANSFORMER = \"transformer_decoder\"" }, { "identifier": "HeadTypes", "path": "utils/constants.py", "snippet": "class HeadTypes:\n TWO_HEAD = \"2head\"\n BASE = \"base\"" }, { "identifier": "Seperators", "path": "utils/constants.py", "snippet": "class Seperators:\n DTD = \"||\"" }, { "identifier": "Tasks", "path": "utils/constants.py", "snippet": "class Tasks:\n # base head tasks\n OCR_READ = \"ocr_read\"\n TEXT_READ = \"text_read\"\n DONUT_KIE = \"donut_kie\"\n OCR_READ_TEXTINSTANCEPADDING = \"ocr_read_TextInstancePadding\"\n TABLE_PARSING = \"table_parsing\"\n OTOR = \"otor\"\n OTOR_ORACLE = \"otor_oracle\"\n\n # 2head tasks\n OCR_READ_2HEAD = \"ocr_read_2head\"" }, { "identifier": "cpu_count", "path": "utils/misc.py", "snippet": "def cpu_count():\n \"\"\"Get number of cpu\n os.cpu_count() has a problem with docker container.\n For example, we have 72 cpus. os.cpu_count() always return 72\n even if we allocate only 4 cpus for container.\n \"\"\"\n return int(subprocess.check_output(\"nproc\").decode().strip())" }, { "identifier": "is_otor", "path": "utils/misc.py", "snippet": "def is_otor(task_name, or_oracle=False, oracle=False):\n if or_oracle:\n if task_name in [\"otor\", \"otor_oracle\"]:\n return True\n elif oracle:\n if task_name == \"otor_oracle\":\n return True\n else:\n if task_name == \"otor\":\n return True\n return False" }, { "identifier": "Singleton", "path": "utils/singleton.py", "snippet": "class Singleton(type):\n _instances: Dict = {}\n\n def __call__(cls, *args, **kwargs):\n if cls not in cls._instances:\n cls._instances[cls] = super().__call__(*args, **kwargs)\n return cls._instances[cls]\n\n def deallocate_instance(cls):\n try:\n del Singleton._instances[cls]\n except KeyError:\n pass" } ]

[ { "identifier": "ChatLogger", "path": "src/python/speck/chat/logger.py", "snippet": "class ChatLogger:\n @staticmethod\n def log(log_config: \"LogConfig\", prompt: Any, model: str, response: Any, **kwargs):\n if kwargs.get(\"config\", {}).get(\"_log\", True):\n universal_format_log(\n log_config=log_config,\n prompt=prompt,\n model=model,\n response=response,\n **kwargs,\n )" }, { "identifier": "run_debug_websocket", "path": "src/python/speck/debug/_debug_socket.py", "snippet": "def run_debug_websocket(client, connector, prompt, config):\n data = asyncio.run(_websocket_client(client, connector, prompt, config))\n return data" } ]

[ { "identifier": "evaluate_model", "path": "evaluate.py", "snippet": "@torch.no_grad()\ndef evaluate_model(\n model,\n tokenizer,\n model_name,\n tasks,\n eval_ppl=\"\",\n num_fewshot=0,\n limit=-1,\n batch_size=1,\n):\n \"\"\"\n model: model name\n limit: number of test samples for debug, set to -1 is no limit\n tasks: str tasks are split by ,\n num_fewshot: Number of examples in few-shot context\n eval_ppl: str datasets are split by , such as 'wikitext2,ptb,c4'\n \"\"\"\n lm = EvalLM(model, tokenizer, batch_size=batch_size)\n results = {}\n if eval_ppl:\n for dataset in eval_ppl.split(\",\"):\n cache_testloader = (\n f\"/tmp/{dataset}_testloader_{model_name.replace('/', '_')}_all.cache\"\n )\n if os.path.exists(cache_testloader):\n testloader = torch.load(cache_testloader)\n # print(f\"load calibration from {cache_testloader}\")\n else:\n testloader = get_eval_loaders(dataset, tokenizer)\n torch.save(testloader, cache_testloader)\n # print(dataset)\n testenc = testloader.input_ids\n nsamples = testenc.numel() // lm.seqlen\n use_cache = lm.model.config.use_cache\n lm.model.config.use_cache = False\n lm.model.eval()\n nlls = []\n\n for i in tqdm(range(nsamples)):\n batch = testenc[:, (i * lm.seqlen) : ((i + 1) * lm.seqlen)].to(\n lm.device\n )\n outputs = lm.model.model(batch)\n hidden_states = outputs[0] # .to(lm.model.lm_head.weight.device)\n logits = lm.model.lm_head(hidden_states) # .contiguous()\n shift_logits = logits[:, :-1, :] # .contiguous()\n shift_labels = testenc[:, (i * lm.seqlen) : ((i + 1) * lm.seqlen)][\n :, 1:\n ].to(lm.device)\n loss_fct = nn.CrossEntropyLoss()\n loss = loss_fct(\n shift_logits.view(-1, shift_logits.size(-1)),\n shift_labels.view(-1),\n )\n neg_log_likelihood = loss.float() * lm.seqlen\n nlls.append(neg_log_likelihood)\n if i == limit:\n break\n # if i == 1:\n # print(\n # \"memory_allocated\",\n # i,\n # torch.cuda.memory_allocated() / 1024 / 1024,\n # \"max memory_allocated\",\n # torch.cuda.max_memory_allocated() / 1024**2,\n # )\n\n ppl = torch.exp(torch.stack(nlls).sum() / (len(nlls) * lm.seqlen))\n print(dataset, ppl.item())\n lm.model.config.use_cache = use_cache\n # pprint(model)\n results[dataset] = ppl.item()\n if tasks == \"mmlu\":\n tasks = \"hendrycksTest-abstract_algebra,hendrycksTest-anatomy,hendrycksTest-astronomy,hendrycksTest-business_ethics,hendrycksTest-clinical_knowledge,hendrycksTest-college_biology,hendrycksTest-college_chemistry,hendrycksTest-college_computer_science,hendrycksTest-college_mathematics,hendrycksTest-college_medicine,hendrycksTest-college_physics,hendrycksTest-computer_security,hendrycksTest-conceptual_physics,hendrycksTest-econometrics,hendrycksTest-electrical_engineering,hendrycksTest-elementary_mathematics,hendrycksTest-formal_logic,hendrycksTest-global_facts,hendrycksTest-high_school_biology,hendrycksTest-high_school_chemistry,hendrycksTest-high_school_computer_science,hendrycksTest-high_school_european_history,hendrycksTest-high_school_geography,hendrycksTest-high_school_government_and_politics,hendrycksTest-high_school_macroeconomics,hendrycksTest-high_school_mathematics,hendrycksTest-high_school_microeconomics,hendrycksTest-high_school_physics,hendrycksTest-high_school_psychology,hendrycksTest-high_school_statistics,hendrycksTest-high_school_us_history,hendrycksTest-high_school_world_history,hendrycksTest-human_aging,hendrycksTest-human_sexuality,hendrycksTest-international_law,hendrycksTest-jurisprudence,hendrycksTest-logical_fallacies,hendrycksTest-machine_learning,hendrycksTest-management,hendrycksTest-marketing,hendrycksTest-medical_genetics,hendrycksTest-miscellaneous,hendrycksTest-moral_disputes,hendrycksTest-moral_scenarios,hendrycksTest-nutrition,hendrycksTest-philosophy,hendrycksTest-prehistory,hendrycksTest-professional_accounting,hendrycksTest-professional_law,hendrycksTest-professional_medicine,hendrycksTest-professional_psychology,hendrycksTest-public_relations,hendrycksTest-security_studies,hendrycksTest-sociology,hendrycksTest-us_foreign_policy,hendrycksTest-virology,hendrycksTest-world_religions\"\n if tasks == \"llmqat\":\n # tasks = \"boolq,piqa,hellaswag,winogrande,arc_easy,arc_challenge,openbookqa\"\n tasks = \"lambada_openai,openbookqa\"\n if tasks != \"\":\n t_results = evaluator.simple_evaluate(\n lm,\n tasks=tasks.split(\",\"),\n batch_size=batch_size,\n num_fewshot=num_fewshot,\n limit=None if limit == -1 else limit,\n no_cache=True,\n )\n t_results = t_results[\"results\"]\n acc_list = [\n t_results[key][\"acc\"] for key in t_results.keys() if \"acc\" in t_results[key]\n ]\n t_results[\"mean\"] = sum(acc_list) / len(acc_list)\n results.update(t_results)\n print(results)\n # print mean\n print(f\"\\n\\n===== mean acc: {sum(acc_list)/len(acc_list)} =====\\n\\n\")\n\n return results" }, { "identifier": "evaluate_perplexity", "path": "evaluate.py", "snippet": "@torch.no_grad()\ndef evaluate_perplexity(model, dataset, limit):\n \"\"\"\n dataset: input ids tensor of shape [batch, sequence length]\n \"\"\"\n nsamples, seqlen = dataset.size()\n\n nlls = []\n\n for i in range(nsamples):\n if i == limit:\n break\n input_ids = dataset[i:i+1,:-1].to(model.device)\n labels = dataset[i:i+1,1:].contiguous()\n logits = model(input_ids=input_ids)[0]\n shift_logits = logits[:, :, :]\n shift_labels = labels.to(model.device)\n loss_fct = nn.CrossEntropyLoss()\n loss = loss_fct(\n shift_logits.view(-1, shift_logits.size(-1)),\n shift_labels.view(-1),\n )\n neg_log_likelihood = loss.float() * seqlen\n nlls.append(neg_log_likelihood)\n ppl = torch.exp(torch.stack(nlls).sum() / (len(nlls) * seqlen))\n return ppl.item()" }, { "identifier": "SVDLinear", "path": "modules/svd_linear.py", "snippet": "class SVDLinear(nn.Module):\n def __init__(self, U, S, V, bias=None,sigma_fuse='UV') -> None:\n super().__init__()\n self.ALinear = nn.Linear(U.size(1), U.size(0), bias=bias is not None)\n \n if bias is not None:\n self.ALinear.bias.data = bias\n self.BLinear = nn.Linear(V.size(1), V.size(0), bias=False)\n self.truncation_rank=S.size(0)\n if sigma_fuse == 'UV':\n self.ALinear.weight.data = U.mul(S.sqrt()).contiguous()\n self.BLinear.weight.data = V.t().mul(S.sqrt().view(-1, 1)).contiguous()\n elif sigma_fuse == 'U':\n self.ALinear.weight.data = U.mul(S).contiguous()\n self.BLinear.weight.data = V.t().contiguous()\n elif sigma_fuse == 'V':\n self.ALinear.weight.data = U.contiguous()\n self.BLinear.weight.data = V.t().mul(S.view(-1, 1)).contiguous()\n \n\n @staticmethod\n def from_linear(\n linear: nn.Linear,\n param_ratio: float,\n act_aware=False,\n ic_split=1,\n oc_split=1,\n alpha=1,\n sigma_fuse=\"UV\"\n ):\n if param_ratio >= 1:\n return linear\n n_params = linear.weight.numel()\n compressed_params = int(n_params * param_ratio)\n assert ic_split == 1 or oc_split == 1\n rank = compressed_params // (linear.in_features + linear.out_features)\n # print(\"rank\", rank)\n w = linear.weight.data.float()\n if act_aware:\n scaling_diag_matrix = 1 # avoid zero division\n if hasattr(linear, \"scaling_diag_matrix\"):\n # print(\"WARNING: scaling_diag_matrix is used\")\n scaling_diag_matrix *= linear.scaling_diag_matrix**alpha\n # scaling_diag_matrix *= linear.scaling_diag_matrix**0.5\n if hasattr(linear, \"fisher_info\"):\n scaling_diag_matrix *= linear.fisher_info**alpha\n # scaling_diag_matrix *= linear.fisher_info**1\n # if not (scaling_diag_matrix == scaling_diag_matrix).all():\n # breakpoint()\n scaling_diag_matrix += 1e-6 # avoid zero division\n w = w * scaling_diag_matrix.view(1, -1)\n Us = []\n Ss = []\n Vs = []\n try:\n U, S, V = torch.svd_lowrank(w, q=rank)\n except:\n print(f\"svd failed for {linear}, disable act_aware\")\n return (\n nn.Linear(linear.in_features, linear.out_features)\n .to(linear.weight.dtype)\n .to(linear.weight.device)\n )\n if act_aware:\n V = V / scaling_diag_matrix.view(-1, 1)\n Us = [U]\n Ss = [S]\n Vs = [V]\n\n if linear.bias is not None:\n bias = linear.bias.data\n else:\n bias = None\n\n # nan or inf check\n for S in Ss:\n if (S!=S).any():\n print(\"nan in S\")\n return (\n nn.Linear(linear.in_features, linear.out_features)\n .to(linear.weight.dtype)\n .to(linear.weight.device)\n )\n for U in Us:\n if (U!=U).any():\n print(\"nan in U\")\n return (\n nn.Linear(linear.in_features, linear.out_features)\n .to(linear.weight.dtype)\n .to(linear.weight.device)\n )\n for V in Vs:\n if (V!=V).any():\n print(\"nan in V\")\n return (\n nn.Linear(linear.in_features, linear.out_features)\n .to(linear.weight.dtype)\n .to(linear.weight.device)\n )\n\n assert len(Us) == len(Ss) == len(Vs) == 1\n new_linear = SVDLinear(Us[0], Ss[0], Vs[0], bias,sigma_fuse)\n return new_linear.to(linear.weight.dtype)\n\n def forward(self, inp):\n # compute USV^Tx + b\n y = self.BLinear(inp)\n y = self.ALinear(y)\n return y" } ]

[ { "identifier": "canonicalize_state_dict", "path": "src/spandrel/__helpers/canonicalize.py", "snippet": "def canonicalize_state_dict(state_dict: StateDict) -> StateDict:\n \"\"\"\n Canonicalize a state dict.\n\n This function is used to canonicalize a state dict, so that it can be\n used for architecture detection and loading.\n\n This function is not intended to be used in production code.\n \"\"\"\n\n # the real state dict might be inside a dict with a known key\n unwrap_keys = [\"state_dict\", \"params_ema\", \"params-ema\", \"params\", \"model\", \"net\"]\n for unwrap_key in unwrap_keys:\n if unwrap_key in state_dict and isinstance(state_dict[unwrap_key], dict):\n state_dict = state_dict[unwrap_key]\n break\n\n # remove known common prefixes\n state_dict = remove_common_prefix(state_dict, [\"module.\", \"netG.\"])\n\n return state_dict" }, { "identifier": "MAIN_REGISTRY", "path": "src/spandrel/__helpers/main_registry.py", "snippet": "MAIN_REGISTRY = ArchRegistry()" }, { "identifier": "ModelDescriptor", "path": "src/spandrel/__helpers/model_descriptor.py", "snippet": "T = TypeVar(\"T\", bound=torch.nn.Module, covariant=True)\n SUPPORTED = 1\n DISCOURAGED = 2\n INTERNAL = 3\nclass SizeRequirements:\nclass ModelTiling(Enum):\nclass ModelBase(ABC, Generic[T]):\nclass ImageModelDescriptor(ModelBase[T], Generic[T]):\nclass MaskedImageModelDescriptor(ModelBase[T], Generic[T]):\n def none(self) -> bool:\n def check(self, width: int, height: int) -> bool:\n def __init__(\n self,\n model: T,\n state_dict: StateDict,\n architecture: str,\n tags: list[str],\n supports_half: bool,\n supports_bfloat16: bool,\n scale: int,\n input_channels: int,\n output_channels: int,\n size_requirements: SizeRequirements | None = None,\n tiling: ModelTiling = ModelTiling.SUPPORTED,\n ):\n def purpose(self) -> Purpose:\n def device(self) -> torch.device:\n def to(self, device: str | torch.device):\n def eval(self):\n def train(self, mode: bool = True):\n def __init__(\n self,\n model: T,\n state_dict: StateDict,\n architecture: str,\n purpose: Literal[\"SR\", \"FaceSR\", \"Restoration\"],\n tags: list[str],\n supports_half: bool,\n supports_bfloat16: bool,\n scale: int,\n input_channels: int,\n output_channels: int,\n size_requirements: SizeRequirements | None = None,\n tiling: ModelTiling = ModelTiling.SUPPORTED,\n call_fn: Callable[[T, Tensor], Tensor] | None = None,\n ):\n def purpose(self) -> Literal[\"SR\", \"FaceSR\", \"Restoration\"]:\n def __call__(self, image: Tensor) -> Tensor:\n def __init__(\n self,\n model: T,\n state_dict: StateDict,\n architecture: str,\n purpose: Literal[\"Inpainting\"],\n tags: list[str],\n supports_half: bool,\n supports_bfloat16: bool,\n input_channels: int,\n output_channels: int,\n size_requirements: SizeRequirements | None = None,\n tiling: ModelTiling = ModelTiling.SUPPORTED,\n call_fn: Callable[[T, Tensor, Tensor], Tensor] | None = None,\n ):\n def purpose(self) -> Literal[\"Inpainting\"]:\n def __call__(self, image: Tensor, mask: Tensor) -> Tensor:" }, { "identifier": "ArchRegistry", "path": "src/spandrel/__helpers/registry.py", "snippet": "class ArchRegistry:\n \"\"\"\n A registry of architectures.\n\n Architectures are detected/loaded in insertion order unless `before` is specified.\n \"\"\"\n\n def __init__(self):\n self._architectures: list[ArchSupport] = []\n self._ordered: list[ArchSupport] = []\n self._by_id: dict[str, ArchSupport] = {}\n\n def copy(self) -> ArchRegistry:\n \"\"\"\n Returns a copy of the registry.\n \"\"\"\n new = ArchRegistry()\n new._architectures = self._architectures.copy()\n new._ordered = self._ordered.copy()\n new._by_id = self._by_id.copy()\n return new\n\n def __contains__(self, id: str) -> bool:\n return id in self._by_id\n\n def __getitem__(self, id: str) -> ArchSupport:\n return self._by_id[id]\n\n def get(self, id: str) -> ArchSupport | None:\n return self._by_id.get(id, None)\n\n def architectures(\n self,\n order: Literal[\"insertion\", \"detection\"] = \"insertion\",\n ) -> list[ArchSupport]:\n \"\"\"\n Returns a new list with all architectures in the registry.\n\n The order of architectures in the list is either insertion order or the order in which architectures are detected.\n \"\"\"\n if order == \"insertion\":\n return list(self._architectures)\n elif order == \"detection\":\n return list(self._ordered)\n else:\n raise ValueError(f\"Invalid order: {order}\")\n\n def add(self, *architectures: ArchSupport):\n \"\"\"\n Adds the given architectures to the registry.\n\n Throws an error if an architecture with the same ID already exists.\n Throws an error if a circular dependency of `before` references is detected.\n\n If an error is thrown, the registry is left unchanged.\n \"\"\"\n\n new_architectures = self._architectures.copy()\n new_by_id = self._by_id.copy()\n for arch in architectures:\n if arch.id in new_by_id:\n raise ValueError(f\"Duplicate architecture ID: {arch.id}\")\n\n new_architectures.append(arch)\n new_by_id[arch.id] = arch\n\n new_ordered = ArchRegistry._get_ordered(new_architectures)\n\n self._architectures = new_architectures\n self._ordered = new_ordered\n self._by_id = new_by_id\n\n @staticmethod\n def _get_ordered(architectures: list[ArchSupport]) -> list[ArchSupport]:\n inv_before: dict[str, list[str]] = {}\n by_id: dict[str, ArchSupport] = {}\n for arch in architectures:\n by_id[arch.id] = arch\n for before in arch.before:\n if before not in inv_before:\n inv_before[before] = []\n inv_before[before].append(arch.id)\n\n ordered: list[ArchSupport] = []\n seen: set[ArchSupport] = set()\n stack: list[str] = []\n\n def visit(arch: ArchSupport):\n if arch.id in stack:\n raise ValueError(\n f\"Circular dependency in architecture detection: {' -> '.join([*stack, arch.id])}\"\n )\n if arch in seen:\n return\n seen.add(arch)\n stack.append(arch.id)\n\n for before in inv_before.get(arch.id, []):\n visit(by_id[before])\n\n ordered.append(arch)\n stack.pop()\n\n for arch in architectures:\n visit(arch)\n\n return ordered\n\n def load(self, state_dict: StateDict) -> ModelDescriptor:\n \"\"\"\n Detects the architecture of the given state dict and loads it.\n\n This will canonicalize the state dict if it isn't already.\n\n Throws an `UnsupportedModelError` if the model architecture is not supported.\n \"\"\"\n\n state_dict = canonicalize_state_dict(state_dict)\n\n for arch in self._ordered:\n if arch.detect(state_dict):\n return arch.load(state_dict)\n\n raise UnsupportedModelError" }, { "identifier": "RestrictedUnpickle", "path": "src/spandrel/__helpers/unpickler.py", "snippet": "class RestrictedUnpickler(pickle.Unpickler):\n def find_class(self, module: str, name: str):" } ]

[ { "identifier": "get_audiobook", "path": "src/audiobook.py", "snippet": "def get_audiobook(json_file, book_title=\"audiobook\", voice=\"onyx\", speed=\"1.0\"):\n book_directory = f\"{book_title}\"\n atexit.register(save_full, book_title)\n\n if not os.path.exists(book_directory):\n os.makedirs(book_directory)\n\n with open(json_file, \"r\") as j:\n vals = json.load(j)\n\n for text_index, text_list in tqdm(enumerate(vals), total=len(vals)):\n audio_section_file = f\"{book_directory}/part{text_index}.mp3\"\n if not os.path.exists(audio_section_file):\n with ThreadPoolExecutor(max_workers=len(text_list)) as executor:\n futures = [executor.submit(play_split_and_combine, i, text, voice, speed) for i, text in enumerate(text_list)]\n combined_audio = AudioSegment.silent(duration=0)\n for future in futures:\n try:\n ind, audio = future.result()\n combined_audio += audio\n except Exception as e:\n print(f\"Error processing segment {ind}: {e}\")\n combined_audio.export(audio_section_file, format=\"mp3\")\n save_full(book_title)" }, { "identifier": "get_rewrite", "path": "src/clean_pdf.py", "snippet": "def get_rewrite(text_json: str, output_json: str):\n with open(text_json, \"r\") as fj:\n text_json: dict[str, list] = json.load(fj)\n if not os.path.exists(output_json):\n with open(output_json, \"w\") as fj:\n json.dump({}, fj)\n with open(output_json, \"r\") as fj:\n current_texts: dict[str, list] = json.load(fj)\n if isinstance(current_texts, list):\n current_texts = {}\n new_texts_json = {}\n for section, chunks in tqdm(text_json.items(), total=len(text_json.keys())):\n if section in current_texts:\n new_texts_json[section] = current_texts[section]\n else:\n with concurrent.futures.ThreadPoolExecutor(max_workers=os.cpu_count() - 1) as executor:\n new_chunks = list(executor.map(gpt_rewrite, chunks))\n new_texts_json[section] = new_chunks\n with open(output_json, \"w\") as js:\n json.dump(new_texts_json, js, indent=2)\n with open(output_json, \"w\") as js:\n final_reformatted_list = finalize_list(new_texts_json)\n json.dump(final_reformatted_list, js, indent=2)" }, { "identifier": "extract_text_from_pdf", "path": "src/pdf_to_json.py", "snippet": "def extract_text_from_pdf(pdf_path, sections, page_difference=0):\n \"\"\"\n Extracts the text from specified sections of a PDF file.\n\n Parameters:\n pdf_path (str): The file path to the PDF file.\n sections (dict): Dictionary specifying sections and their corresponding page ranges.\n\n Returns:\n dict: Dictionary where keys are section titles and values are extracted text for each section.\n \"\"\"\n doc = fitz.open(pdf_path)\n section_ranges = [(title, (s + page_difference, e + page_difference)) for title, (s, e) in sections.items()]\n section_texts = {}\n for page_num in tqdm(range(1, len(doc) + 1)):\n page = doc[page_num - 1]\n cleaned_text = page.get_text()\n # Dictionary to store the extracted text for each section\n for title, (start, end) in section_ranges:\n if start <= page_num <= end:\n cleaned_text = cleaned_text.replace('–', '-').replace('—', '-') # Replace en-dash and em-dash with hyphen\n cleaned_text = cleaned_text.replace(\"\\x0c\", \"\") # Replace line breaks with spaces\n\n cleaned_text = spellcheck(cleaned_text).text\n \n # Append the processed text to the respective section\n if title in section_texts:\n section_texts[title] += cleaned_text\n else:\n section_texts[title] = cleaned_text\n break\n section_chunks = {}\n overall_count = 0\n total_text = \"\"\n for title, text in section_texts.items():\n total_text += text\n chunks = split_into_chunks(text)\n current_chunks = list()\n for i, chunk in enumerate(chunks):\n current_chunks.append(chunk)\n if i % 3 == 0 and i != 0:\n section_chunks[overall_count] = current_chunks\n overall_count += 1\n current_chunks = list()\n section_chunks[overall_count] = current_chunks\n\n encoding = tiktoken.encoding_for_model('gpt-3.5-turbo')\n total_tokens = len(encoding.encode(total_text))\n rewrite_cost = (total_tokens/1000) * 0.0030\n audio_cost = ((len(total_text) * 4/5)/1000) * 0.015\n audio_time = (len(total_text) * 4/5) * 0.0014\n rewrite_time = (0.0145) * total_tokens\n total_time = audio_time + rewrite_time\n total_time_secs = str(int(total_time % 60))\n total_time_mins = str(int(total_time // 60))\n total_time_str = f\"{total_time_mins} mins {total_time_secs} secs\"\n total_cost = round(rewrite_cost + audio_cost, 2)\n total_cost_str = f\"{total_cost} $\"\n with open(pdf_path.replace(\".pdf\", \".json\"), \"w\", encoding=\"utf-8\") as sections_json:\n json.dump(section_chunks, sections_json, indent=2)\n return total_cost_str, total_time_str" } ]

[ { "identifier": "Transaction", "path": "api/transactions/models.py", "snippet": "class Transaction(models.Model):\n TRANSACTION_TYPES = [\n ('DEPOSIT', 'Deposit'),\n ('TRANSFER', 'Transfer'),\n ('DEBIT_CARD', 'Debit Card'),\n ('PAYMENT', 'Payment'),\n ]\n\n account = models.ForeignKey(Account, on_delete=models.CASCADE, default=11)\n account_number = models.BigIntegerField()\n transaction_type = models.CharField(max_length=20, choices=TRANSACTION_TYPES, default=\"DEPOSIT\")\n amount = models.DecimalField(max_digits=15, decimal_places=2)\n identifier = models.UUIDField(default=uuid.uuid4, editable=False, unique=True)\n date = models.DateTimeField(auto_now_add=True)\n\n def __str__(self):\n return f\"Transaction ID: {self.pk} - Type: {self.get_transaction_type_display()} - Amount: {self.amount}\"" }, { "identifier": "TransactionSerializer", "path": "api/transactions/serializers.py", "snippet": "class TransactionSerializer(serializers.ModelSerializer):\n date = serializers.DateTimeField(read_only=True)\n account = AccountSerializer(read_only=True)\n account_number = serializers.CharField(write_only=True)\n\n class Meta:\n model = Transaction\n fields = [\n \"id\",\n \"account\",\n \"account_number\",\n \"transaction_type\",\n \"amount\",\n \"identifier\",\n \"date\",\n ]\n\n extra_kwargs = {\n \"account\": {\"read_only\": True},\n }" }, { "identifier": "TransferTransactionSerializer", "path": "api/transactions/serializers.py", "snippet": "class TransferTransactionSerializer(serializers.ModelSerializer):\n date = serializers.DateTimeField(read_only=True)\n transaction_partner_account_number = serializers.CharField(write_only=True)\n account = AccountSerializer(read_only=True)\n account_number = serializers.CharField(write_only=True)\n\n class Meta:\n model = Transaction\n fields = [\n \"account\",\n \"account_number\",\n \"transaction_partner_account_number\",\n \"transaction_type\",\n \"amount\",\n \"identifier\",\n \"date\",\n ]\n\n extra_kwargs = {\n \"transaction_type\": {\"read_only\": True},\n }" }, { "identifier": "DebitCardPaymentSerializer", "path": "api/transactions/serializers.py", "snippet": "class DebitCardPaymentSerializer(serializers.ModelSerializer):\n account = AccountSerializer(read_only=True)\n cvv = serializers.CharField(write_only=True)\n card_number = serializers.CharField(write_only=True)\n expiry_date = serializers.CharField(write_only=True)\n cvv = serializers.CharField(write_only=True)\n\n\n class Meta:\n model = Transaction\n fields = [\n \"account\",\n \"account_number\",\n \"card_number\",\n \"transaction_type\",\n \"expiry_date\",\n \"cvv\",\n \"amount\",\n \"identifier\",\n \"date\",\n ]" }, { "identifier": "TransactionHistorySerializer", "path": "api/transactions/serializers.py", "snippet": "class TransactionHistorySerializer(serializers.ModelSerializer):\n class Meta:\n model = Transaction\n fields = [\"transaction_type\"]\n\n # Custom representation method to handle serialization based on transaction type\n def to_representation(self, instance):\n from transfers.serializers import TransferSerializer\n from debit_cards.serializers import TransactionDebitCardSerializer\n from deposits.serializers import DepositSerializer\n\n # Fetching transaction type, current user, and URL name from context\n transaction_type = instance.transaction_type\n user = self.context['request'].user\n url_name = self.context['request'].resolver_match.url_name\n \n # Initializing serializer and related_instance variables\n serializer = None\n related_instance = None\n \n # Checking transaction type and assigning related instance accordingly\n if transaction_type == 'TRANSFER':\n related_instance = instance.transfer\n elif transaction_type == 'DEBIT_CARD':\n related_instance = instance.debit_card\n elif transaction_type == 'DEPOSIT':\n related_instance = instance.deposit\n \n if related_instance:\n # Checking permissions based on transaction type and user access\n if transaction_type == 'DEPOSIT' or (related_instance.transaction.account.user == user or url_name == 'transactions_detail'):\n # Initializing the appropriate serializer based on transaction type\n if transaction_type == 'TRANSFER':\n serializer = TransferSerializer(instance=related_instance, context={'request': self.context['request']})\n elif transaction_type == 'DEBIT_CARD':\n serializer = TransactionDebitCardSerializer(instance=related_instance, context={'request': self.context['request']})\n elif transaction_type == 'DEPOSIT':\n serializer = DepositSerializer(instance=related_instance, context={'request': self.context['request']})\n\n # Returning serialized data if serializer exists and has a 'data' attribute, otherwise None\n return serializer.data if (serializer and hasattr(serializer, 'data')) else serializer" } ]

[ { "identifier": "logger", "path": "openserver/core/utils/utils.py", "snippet": "def trim_string(string, count: int) -> str:\ndef run_with_time(func):" }, { "identifier": "extract_json_from_string", "path": "openserver/core/utils/json.py", "snippet": "def extract_json_from_string(text: str):\n json_str = parse_json_markdown(text, parser=parse_partial_json)\n if json_str is None:\n json_str = extract_json(text, parser=parse_partial_json)\n if isinstance(json_str, list) and len(json_str) > 0:\n json_str = json_str[0]\n return json_str" }, { "identifier": "base_messages_to_default", "path": "openserver/core/utils/langchain.py", "snippet": "def base_messages_to_default(messages: List[BaseMessage]):\n new_messages = []\n for message in messages:\n if message.type.lower() in [\"system\"]:\n new_messages.append(SystemMessage(content=message.content))\n elif message.type.lower() in [\"human\", \"user\"]:\n new_messages.append(HumanMessage(content=message.content))\n elif message.type.lower() in [\"assisstant\", \"ai\", \"chat\"]:\n new_messages.append(AIMessage(content=message.content))\n else:\n new_messages.append(message)\n return new_messages " }, { "identifier": "ChatConfig", "path": "openserver/core/config/chat_config.py", "snippet": "class ChatConfig(BaseConfig):\n\n def __init__(self, with_envs: bool = False):\n configs = init_config(\"configs/chat_config.yaml\", with_envs)\n self.configs = configs\n self.chat_providers: ConfigProvidersIn = self.parse(configs.get_configs().get(\n \"chat_providers\") or {})\n\n def get_chat_providers(self, model: str, functions: bool):\n providers = self.functions_available(functions)\n providers = self.chat_providers.find_model(providers, model)\n provider = self.chat_providers.choose_model(providers, model)\n return provider\n\n def functions_available(self, functions: bool):\n if functions is True:\n return list(filter(lambda x: x.args.get(\"functions\") is True, self.chat_providers.providers))\n return self.chat_providers.providers" }, { "identifier": "PromptConfig", "path": "openserver/core/config/prompt_config.py", "snippet": "class PromptConfig:\n\n def __init__(self):\n configs = init_config(\"configs/prompts_config.yaml\")\n self.configs = configs\n self.prompts: Dict[str, Any] = configs.get_configs().get(\n \"prompts\") # type: ignore\n\n def prompt_template(self, type=\"function_call\", **kwargs):\n prompt_template = \"\"\n if self.prompts.get(type) == None:\n raise ValueError(f\"There is no prompt template name : {type}\")\n if self.prompts[type].get(\"content\") == None:\n self.add_prompt_to_config()\n prompt_template = self.prompts[type][\"content\"]\n return prompt_template\n\n def add_prompt_to_config(self):\n ROOT_DIR: str = os.path.dirname(Path(__file__).parent.parent.parent)\n for prompt in self.prompts:\n prompt_path = self.prompts[prompt][\"file\"]\n prompt_file = ROOT_DIR + \"/\" + prompt_path\n\n if os.path.exists(prompt_file):\n with open(prompt_file, \"r\") as file:\n self.prompts[prompt][\"content\"] = file.read()\n\n def extract_text(self, text: str, **kwargs):\n pattern = r'<<(.*?)>>(.*?)<</\\1>>'\n matches = re.findall(pattern, text, re.DOTALL)\n messages = [BaseMessage(type=tag, content=content.format(\n **kwargs)) for tag, content in matches]\n return base_messages_to_default(messages)" }, { "identifier": "LLmInputInterface", "path": "openserver/core/llm_models/base.py", "snippet": "class LLmInputInterface:\n def __init__(self, model: str, api_key: str | None = None, stop: List[str] = [\"### Humen:\", \"### Instruction:\", \"### Assistant:\", \"\\nQuestion:\"], max_tokens=4196, repeat_penalty=0.2,\n responses: List[str] | None = None, top_k=30, top_p=0.95, streaming: bool = False, temperature=0.2, cache=True, verbose=True, max_retries=10, n_ctx: int = 2048, f16_kv=True, \n n_gpu_layers: int = 50, n_threads=4, metadata: Dict[str, Any] | None = None, callbacks: Callbacks | None = None, grammer: str | LlamaGrammar | None = None, \n grammer_path: str | Path | None = None, model_kwargs={}, base_url: str | None = None):\n self.api_key: str | None = api_key\n self.model_name: str = model\n self.model_kwargs: Dict[str, Any] = model_kwargs\n self.stop: List[str] = stop\n self.max_tokens: int = max_tokens\n self.repeat_penalty: float = repeat_penalty\n self.top_k: int = top_k\n self.top_p: float = top_p\n self.temperature: float = temperature\n self.cache: bool = cache\n self.verbose: bool = verbose\n self.max_retries: int = max_retries\n self.responses: List[str] | None = responses\n self.stream: bool = streaming\n self.n_ctx: int = n_ctx\n self.f16_kv: bool = f16_kv\n self.n_gpu_layers: int = n_gpu_layers\n self.n_threads: int = n_threads\n self.grammer: str | LlamaGrammar | None = grammer\n self.grammer_path: str | Path | None = grammer_path\n self.callbacks: Callbacks = callbacks\n self.metadata = metadata\n self.base_url = base_url" }, { "identifier": "LLMFactory", "path": "openserver/core/llm_models/llm_model_factory.py", "snippet": "class LLMFactory:\n\n @classmethod\n def get_model(cls, input: LLmInputInterface, provider_name: LLMType | str = 'free'):\n if isinstance(provider_name, str):\n provider_name = LLMType.get_type(provider_name.lower())\n\n if provider_name == LLMType.OPENAI:\n return OpenAIModel(input)\n\n elif provider_name == LLMType.COHERE:\n return CohereModel(input)\n\n elif provider_name == LLMType.LLAMACPP:\n return LlamaCppModel(input)\n\n elif provider_name == LLMType.FAKE:\n return FakeModel(input)\n\n elif provider_name == LLMType.AI21:\n return AI21Model(input)\n\n elif provider_name == LLMType.FIREWORKS:\n return FireworksModel(input)\n\n elif provider_name == LLMType.PALM:\n return GooglePalmModel(input)\n\n elif provider_name == LLMType.TOGETHER:\n return TogetherModel(input)\n\n else:\n return G4FModel(input)\n\n @classmethod\n def get_chat_model(cls, input: LLmInputInterface, provider_name: LLMType | str = 'free'):\n if isinstance(provider_name, str):\n provider_name = LLMType.get_type(provider_name.lower())\n\n if provider_name == LLMType.OPENAI:\n return ChatOpenAIModel(input)\n\n elif provider_name == LLMType.PALM:\n return ChatGooglePalmModel(input)\n\n elif provider_name == LLMType.COHERE:\n return ChatCohereModel(input)\n\n elif provider_name == LLMType.FAKE:\n return FakeChatModel(input)\n\n elif provider_name == LLMType.FIREWORKS:\n return ChatFireworksModel(input)\n\n elif provider_name == LLMType.TOGETHER:\n # else:\n return ChatTogetherModel(input)\n\n else:\n return ChatG4FModel(input)" }, { "identifier": "completion_price_calculator", "path": "openserver/core/utils/cost.py", "snippet": "def completion_price_calculator(cost_prompt: float, cost_completion: float, prompt_token: int, completion_token: int):\n cost_inp = cost_prompt / 1000000 * prompt_token\n cost_out = cost_completion / 1000000 * completion_token\n return round(cost_inp + cost_out, 7)" }, { "identifier": "app", "path": "openserver/server/app.py", "snippet": "" }, { "identifier": "llm_result_to_str", "path": "openserver/server/utils.py", "snippet": "def llm_result_to_str(response: LLMResult):\n final_result = \"\"\n\n for generation in response.generations:\n for item in generation:\n final_result += item.text\n return final_result" }, { "identifier": "num_tokens_from_string", "path": "openserver/server/utils.py", "snippet": "def num_tokens_from_string(string: str, encoding_name: str = \"cl100k_base\") -> int:\n \"\"\"Returns the number of tokens in a text string.\"\"\"\n encoding = tiktoken.get_encoding(encoding_name)\n num_tokens = len(encoding.encode(string))\n return num_tokens" } ]

[ { "identifier": "config", "path": "hyperfast/config.py", "snippet": "" }, { "identifier": "seed_everything", "path": "hyperfast/utils.py", "snippet": "def seed_everything(seed: int):\n random.seed(seed)\n os.environ[\"PYTHONHASHSEED\"] = str(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n torch.set_num_threads(1)" }, { "identifier": "transform_data_for_main_network", "path": "hyperfast/utils.py", "snippet": "def transform_data_for_main_network(X, cfg, rf, pca):\n with torch.no_grad():\n X = rf(X)\n if cfg.torch_pca:\n X = pca.transform(X)\n else:\n X = torch.from_numpy(pca.transform(X.cpu().numpy())).to(cfg.device)\n X = torch.clamp(X, -cfg.clip_data_value, cfg.clip_data_value)\n return X" }, { "identifier": "forward_main_network", "path": "hyperfast/utils.py", "snippet": "def forward_main_network(x, main_network):\n for n, layer in enumerate(main_network):\n if n % 2 == 0:\n residual_connection = x\n matrix, bias = layer\n x = torch.mm(x, matrix) + bias\n if n % 2 == 1 and n != len(main_network) - 1:\n x = x + residual_connection\n\n if n != len(main_network) - 1:\n x = F.relu(x)\n if n == len(main_network) - 2:\n intermediate_activations = x\n return x, intermediate_activations" }, { "identifier": "nn_bias_logits", "path": "hyperfast/utils.py", "snippet": "def nn_bias_logits(\n test_logits, test_samples, train_samples, train_labels, bias_param, n_classes\n):\n with torch.no_grad():\n nn = NN(train_samples, train_labels)\n preds = nn.predict(test_samples)\n preds_onehot = F.one_hot(preds, n_classes)\n test_logits[preds_onehot.bool()] += bias_param\n return test_logits" }, { "identifier": "fine_tune_main_network", "path": "hyperfast/utils.py", "snippet": "def fine_tune_main_network(\n cfg,\n X,\n y,\n n_classes,\n rf,\n pca,\n main_network_layers,\n nn_bias,\n device,\n optimize_steps,\n batch_size,\n):\n main_model = MainNetworkTrainable(\n cfg, n_classes, rf, pca, main_network_layers, nn_bias\n ).to(device)\n dataset = TensorDataset(X, y)\n dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)\n criterion = nn.CrossEntropyLoss()\n optimizer = optim.AdamW(main_model.parameters(), lr=cfg.lr)\n scheduler = optim.lr_scheduler.ReduceLROnPlateau(\n optimizer, mode=\"min\", factor=0.1, patience=10, verbose=True\n )\n\n for step in range(optimize_steps):\n for inputs, targets in dataloader:\n optimizer.zero_grad()\n outputs = main_model(inputs, targets)\n loss = criterion(outputs, targets)\n loss.backward()\n optimizer.step()\n # print(f\"Step: [{step+1}/{optimize_steps}], Loss: {loss.item()}\")\n\n if scheduler is not None:\n if isinstance(scheduler, optim.lr_scheduler.ReduceLROnPlateau):\n scheduler.step(loss.item())\n else:\n scheduler.step()\n return main_model.get_main_network_parts()" }, { "identifier": "HyperFast", "path": "hyperfast/model.py", "snippet": "class HyperFast(nn.Module):\n def __init__(self, cfg):\n super().__init__()\n self.n_dims = cfg.n_dims\n self.max_categories = cfg.max_categories\n self.rf_size = cfg.rf_size\n self.torch_pca = cfg.torch_pca\n self.clip_data_value = cfg.clip_data_value\n self.hn_n_layers = cfg.hn_n_layers\n self.hn_hidden_size = cfg.hn_hidden_size\n self.main_n_layers = cfg.main_n_layers\n\n middle_layers = []\n for n in range(self.hn_n_layers - 2):\n middle_layers.append(nn.Linear(self.hn_hidden_size, self.hn_hidden_size))\n middle_layers.append(nn.ReLU())\n self.num_input_features_hn = self.n_dims + self.max_categories\n\n self.hypernetworks = nn.ModuleList()\n self.hn_emb_to_weights = nn.ModuleList()\n\n for n in range(self.main_n_layers - 1):\n if n > 0:\n self.num_input_features_hn = self.n_dims * 2 + self.max_categories\n num_input_features_hn = self.num_input_features_hn + self.n_dims * 2\n\n hn_layers = []\n hn_layers.append(nn.Linear(num_input_features_hn, self.hn_hidden_size))\n hn_layers.append(nn.ReLU())\n hn_layers = hn_layers + middle_layers\n\n self.hypernetworks.append(nn.Sequential(*hn_layers))\n self.output_size_hn = (self.n_dims + 1) * self.n_dims\n self.hn_emb_to_weights.append(\n nn.Linear(self.hn_hidden_size, self.output_size_hn)\n )\n\n hn_layers = []\n last_hn_output_size = self.n_dims + 1\n self.num_input_features_hn += self.n_dims * 2\n\n hn_layers.append(nn.Linear(self.num_input_features_hn, self.hn_hidden_size))\n hn_layers.append(nn.ReLU())\n hn_layers = hn_layers + middle_layers\n hn_layers.append(nn.Linear(self.hn_hidden_size, last_hn_output_size))\n self.hypernetworks.append(nn.Sequential(*hn_layers))\n self.nn_bias = nn.Parameter(torch.ones(2))\n\n def forward(self, X, y, n_classes):\n X = X.flatten(start_dim=1)\n rf_linear = nn.Linear(X.shape[1], self.rf_size, bias=False)\n nn.init.kaiming_normal_(rf_linear.weight, mode=\"fan_out\", nonlinearity=\"relu\")\n rf_linear.weight.requires_grad = False\n rf = nn.Sequential(rf_linear, nn.ReLU()).to(X.device)\n with torch.no_grad():\n X = rf(X)\n if self.torch_pca:\n self.pca = TorchPCA(n_components=self.n_dims)\n else:\n self.pca = PCA(n_components=self.n_dims)\n if self.torch_pca:\n X = self.pca.fit_transform(X)\n else:\n X = torch.from_numpy(self.pca.fit_transform(X.cpu().numpy())).to(X.device)\n X = torch.clamp(X, -self.clip_data_value, self.clip_data_value)\n\n out = X\n pca_global_mean = torch.mean(out, axis=0)\n pca_perclass_mean = []\n for lab in range(n_classes):\n if torch.sum((y == lab)) > 0:\n class_mean = torch.mean(out[y == lab], dim=0, keepdim=True)\n else:\n class_mean = torch.mean(out, dim=0, keepdim=True)\n pca_perclass_mean.append(class_mean)\n pca_perclass_mean = torch.cat(pca_perclass_mean)\n\n pca_concat = []\n for ii, lab in enumerate(y):\n if pca_perclass_mean.ndim == 1:\n pca_perclass_mean = pca_perclass_mean.unsqueeze(0)\n if out.ndim == 1:\n out = out.unsqueeze(0)\n\n lab_index = lab.item() if torch.is_tensor(lab) else lab\n lab_index = min(lab_index, pca_perclass_mean.size(0) - 1)\n\n row = torch.cat((out[ii], pca_global_mean, pca_perclass_mean[lab_index]))\n pca_concat.append(row)\n pca_output = torch.vstack(pca_concat)\n y_onehot = F.one_hot(y, self.max_categories)\n\n main_network = []\n for n in range(self.main_n_layers - 1):\n if n > 0:\n data = torch.cat((out, pca_output, y_onehot), dim=1)\n else:\n data = torch.cat((pca_output, y_onehot), dim=1)\n if n % 2 == 0:\n residual_connection = out\n\n weights = get_main_weights(\n data, self.hypernetworks[n], self.hn_emb_to_weights[n]\n )\n out, main_linear_layer = forward_linear_layer(out, weights, self.n_dims)\n if n % 2 == 0:\n out = F.relu(out)\n else:\n out = out + residual_connection\n out = F.relu(out)\n main_network.append(main_linear_layer)\n data = torch.cat((out, pca_output, y_onehot), dim=1)\n weights_per_sample = get_main_weights(data, self.hypernetworks[-1])\n\n weights = []\n last_input_mean = []\n for lab in range(n_classes):\n if torch.sum((y == lab)) > 0:\n w = torch.mean(weights_per_sample[y == lab], dim=0, keepdim=True)\n input_mean = torch.mean(out[y == lab], dim=0, keepdim=True)\n else:\n w = torch.mean(weights_per_sample, dim=0, keepdim=True)\n input_mean = torch.mean(out, dim=0, keepdim=True)\n weights.append(w)\n last_input_mean.append(input_mean)\n weights = torch.cat(weights)\n last_input_mean = torch.cat(last_input_mean)\n weights[:, :-1] = weights[:, :-1] + last_input_mean\n weights = weights.T\n out, last_linear_layer = forward_linear_layer(out, weights, n_classes)\n main_network.append(last_linear_layer)\n\n return rf, self.pca, main_network" } ]

[ { "identifier": "from_nd_converter", "path": "node_api_conversion/from_nd_converter.py", "snippet": "def adjust_padding(padding, kernel_size):\ndef convert_node(node: nd.nodes, inst: nd.nodes.NodeInstance = None) -> torch.nn.Module:\ndef _(node: nd.cells.Cell, inst: nd.nodes.NodeInstance = None) -> torch.nn.Module:\ndef _(node: nd.ops.Conv2D, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.DepthwiseConv, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Conv2DTranspose, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Dense, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.BatchNorm, inst: nd.nodes.NodeInstance):\ndef _(node: nd.ops.EfficientAttention, inst: nd.nodes.NodeInstance):\ndef _(node: nd.ops.LayerNormalization, inst: nd.nodes.NodeInstance):\ndef _(node: nd.ops.Activation, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.ZeroPadding2D, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.MaxPool2D, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.GlobalMeanPool2D, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Flatten, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Sum, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Sub, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Mul, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.ChannelAffine, inst: nd.nodes.NodeInstance = None):\ndef _(node: LambdaOpNode, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.MeanPool2D, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.TokenizeImage, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.DetokenizeImage, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.MatMul, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.SubpixelDownSampling, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Concat, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.TfImageResize, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Reshape, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Dropout, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.TensorMerger, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.TensorExtractor, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.BilinearUpSampling, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Reduce, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.Split, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.SubpixelDownSampling, inst: nd.nodes.NodeInstance = None):\ndef _(node: nd.ops.SubpixelUpSampling, inst: nd.nodes.NodeInstance = None):\ndef get_torch_tensor(tensor: nd.backend.VARIABLE_AND_TENSOR_TYPE):\ndef find_instance(\n icn: nd.cells.InnerCellNode,\n cell_instance: nd.cells.CellInstance,\n) -> nd.nodes.NodeInstance:\ndef build_from_cell(\n cell: nd.cells.Cell,\n cell_instance: nd.cells.CellInstance,\n) -> dag_module.DagModule:\ndef convert_cell_to_torch_dag_module(\n cell: nd.cells.Cell,\n input_shape_without_batch: Tuple[int, ...],\n batch_size_for_verification: int = 4,\n) -> Tuple[dag_module.DagModule, float]:" }, { "identifier": "DagVisualizer", "path": "torch_dag/visualization/visualize_dag.py", "snippet": "class DagVisualizer:\n\n def __init__(self, dag: DagModule):\n self.dag = dag\n self.dag.cache_forward_dict = True\n self.flops_list = None\n\n @staticmethod\n def get_name(namescope_index: str, index: str):\n if namescope_index is None:\n return f\"{index}\"\n else:\n return f\"{namescope_index}_{index}\"\n\n def visualize(\n self,\n max_depth: int = 0,\n input_shape: Tuple[int, ...] = None,\n saving_path: Optional[str] = None,\n saving_format: str = \"pdf\",\n ):\n if input_shape is not None:\n self.dag.eval()\n _ = self.dag(torch.ones(size=input_shape))\n if max_depth == 0:\n self.flops_list = build_full_flops_list(\n dag=self.dag, input_shape_without_batch=input_shape[1:], normalize=True)\n\n graph, input_node_names, output_node_names = self._visualize(\n dag=self.dag,\n max_depth=max_depth,\n )\n if saving_path is not None:\n graph.render(saving_path, format=saving_format)\n\n return graph\n\n # def get_weights_stats(self, node: nd.nodes.Node):\n # if isinstance(node, (nd.ops.Conv2D, nd.ops.DepthwiseConv)):\n # return self.compute_tensor_stats(node.filters)\n # elif isinstance(node, nd.ops.Dense):\n # return self.compute_tensor_stats(node.kernel)\n # else:\n # return None\n\n def get_module_meta(self, module: nn.Module) -> Dict:\n meta = {}\n if isinstance(module, nn.Conv2d):\n meta['kernel_size'] = module.kernel_size\n meta['in_channels'] = module.in_channels\n meta['out_channels'] = module.out_channels\n meta['groups'] = module.groups\n elif isinstance(module, smodules.ACTIVATION_MODULES):\n meta['activation_function'] = module.__class__.__name__\n # weights_stats = self.get_weights_stats(node)\n # if weights_stats is not None:\n # mean, std, maximum, minimum = weights_stats\n # meta['weights_mean_std_max_min'] = f'{mean:.3f}, {std:.3f}, {maximum:.3f}, {minimum:.3f}'\n\n return meta\n\n def add_nested_dag_as_subgraph(\n self,\n g: graphviz.Digraph,\n name: str,\n dag: DagModule,\n depth: int,\n max_depth: int,\n ) -> Tuple[graphviz.Digraph, List[str], List[str]]:\n with g.subgraph(name=f'cluster_{dag.name}') as s:\n fillcolor = self.get_depth_fill_color(depth)\n s.attr(\n label=f'{dag.name}',\n style='filled',\n fillcolor=fillcolor,\n )\n return self._visualize(\n dag=dag,\n graph=s,\n namescope_index=name,\n max_depth=max_depth,\n depth=depth,\n )\n\n def get_depth_fill_color(self, depth: int):\n if depth == 1:\n return DEPTH_1_FILL_COLOR\n elif depth == 2:\n return DEPTH_2_FILL_COLOR\n\n def compute_tensor_stats(self, tensor: torch.Tensor):\n mean = tensor.mean()\n std = torch.std(tensor)\n maximum = tensor.max()\n minimum = tensor.min()\n return mean, std, maximum, minimum\n\n def _visualize(\n self,\n dag: DagModule,\n graph: graphviz.Digraph = None,\n namescope_index: str = None,\n max_depth: int = 0,\n depth: int = 0,\n ) -> Tuple[graphviz.Digraph, List[str], List[str]]:\n if graph is None:\n g = graphviz.Digraph('model')\n else:\n g = graph\n g.node_attr.update(style='filled', shape='box')\n go_deeper = True if max_depth > 0 else False\n names = {}\n input_vertex_names = []\n output_vertex_names = []\n for k, vertex in enumerate(dag.vertices):\n name = self.get_name(namescope_index, str(k))\n names[k] = name\n if isinstance(vertex, InputVertex):\n label = f'input_{k}'\n g.node(\n name,\n label=label,\n color=NODE_SHAPE_COLOR,\n fillcolor=INPUT_COLOR,\n shape=INPUT_SHAPE,\n )\n input_vertex_names.append(name)\n\n else:\n predecessors_indices = [dag.vertices.index(pd) for pd in vertex.predecessors]\n if isinstance(vertex.module, DagModule) and go_deeper:\n sgraph, inputs, outputs = self.add_nested_dag_as_subgraph(\n g=g,\n name=name,\n dag=vertex.module,\n depth=depth + 1,\n max_depth=max_depth - 1\n )\n\n for l, pd in enumerate(predecessors_indices):\n edge = names[pd], inputs[l]\n g.edge(edge[0], edge[1])\n names[k] = outputs[0]\n if vertex == dag.output_vertex:\n output_vertex_names = [name]\n\n else:\n module = vertex.module\n fillcolor = get_vertex_color(module)\n color = get_vertex_color(module)\n\n label = f'{vertex.name}'\n label += f'_idx_{dag.vertices.index(vertex)}'\n if max_depth == 0 and depth == 0 and self.flops_list is not None:\n flops = self.flops_list[self.dag.inner_vertices.index(vertex)]\n label += f' \\n kmapp: {flops}'\n if vertex.orbit is not None:\n label += f' \\n orbit: {vertex.orbit}'\n\n if len(self.get_module_meta(module).keys()) > 0:\n label += f' \\n ----------'\n\n # add meta node info\n for key, value in self.get_module_meta(module).items():\n label += f' \\n {key}: {value}'\n\n # add output shape visualization\n if dag.forward_dict is not None:\n if isinstance(vertex.module, smodules.ArgModule):\n pass\n else:\n label += f' \\n ----------'\n tensors = dag.forward_dict[vertex]\n if not isinstance(dag.forward_dict[vertex], List):\n tensors = [tensors]\n shapes = []\n for el in tensors:\n if isinstance(el, torch.Tensor):\n shapes.append(tuple([int(e) for e in el.shape]))\n else:\n shapes.append(tuple())\n\n for tensor, shape in zip(tensors, shapes):\n label += f' \\n {shape}'\n if isinstance(tensor, torch.Tensor) and tensor.dtype == torch.float:\n mean, std, maximum, minimum = self.compute_tensor_stats(tensor)\n label += f' \\n mean: {mean:.3f}, std: {std:.3f}, max: {maximum:.3f}, min: {minimum:.3f}'\n\n if vertex == dag.output_vertex:\n shape = OUTPUT_SHAPE\n fillcolor = f'{OUTPUT_COLOR}:{fillcolor}'\n output_vertex_names = [name]\n else:\n shape = NODE_SHAPE\n\n g.node(\n name,\n label=label,\n shape=shape,\n color=NODE_SHAPE_COLOR,\n fillcolor=fillcolor,\n )\n for pd in predecessors_indices:\n edge = names[pd], names[k]\n g.edge(edge[0], edge[1])\n\n return g, input_vertex_names, output_vertex_names" }, { "identifier": "log_cell_characteristics", "path": "node_api_conversion/utils.py", "snippet": "def log_cell_characteristics(\n cell: nd.cells.Cell,\n input_shape_without_batch: Tuple[int, ...],\n):\n if len(input_shape_without_batch) < 2:\n logger.warning(f'One cannot compute `kmapp` for cell: {cell.name}, since the input_shape_without_batch '\n f'has length less than 2.')\n return\n cell.predict()\n static_kmapp = compute_static_kmapp(cell, input_shape_without_batch)\n static_multiadds = compute_static_kmapp(cell, input_shape_without_batch, normalized=False)\n x = tf.ones(shape=(1,) + input_shape_without_batch)\n result = cell(x)\n logger.info(f'static_kmapp: {static_kmapp}')\n logger.info(f'static_multiadds (M): {static_multiadds / 1e6}')\n num_params = get_num_params(cell) / 1e6\n logger.info(f'number params (M): {num_params}')\n logger.info(f'number of output tensors: {len(result.output_tensors)}')\n for k, tensor in enumerate(result.output_tensors):\n logger.info(f'output shape of output tensor {k}: {tensor.shape}')" } ]

[ { "identifier": "ChatAgent", "path": "simple_ai_agents/chat_agent.py", "snippet": "class ChatAgent(BaseModel):\n \"\"\"\n A chatbot class that provides additional functionality\n for creating and managing chat sessions.\n\n Args:\n character (str, optional): The name of the chatbot for console display.\n Defaults to None.\n system (str, optional): System prompt for chatbot message.\n If None is provided it defaults to \"You are a helpful assistant.\"\n id (Union[str, UUID], optional): Initial session ID of the chatbot.\n Defaults to uuid4().\n prime (bool, optional): Whether to prime the chatbot with initial messages.\n Defaults to True.\n default_session (bool, optional): Whether to create a default chat session.\n Defaults to True.\n console (bool, optional): Whether to enable interactive console mode.\n Defaults to False.\n **kwargs: Additional options to pass to the `new_session` method.\n To customize GPT options, pass a `llm_options` dictionary.\n\n Attributes:\n sessions (dict): A dictionary of chat sessions,\n where the keys are the session IDs and the values\n are the corresponding `ChatSession` objects.\n default_session (ChatSession): The default chat session.\n character (str): The name of the chatbot for console display.\n ai_text_color (str): Print color of the chatbot's messages.\n\n Methods:\n new_session: Creates a new chat session.\n interactive_console: Starts an interactive console for the chatbot.\n \"\"\"\n\n default_session: Optional[ChatLLMSession]\n sessions: Dict[Union[str, UUID], ChatLLMSession] = {}\n character: Optional[str] = \"Chat Agent\"\n ai_text_color: str = \"bright_magenta\"\n\n def __init__(\n self,\n character: Optional[str] = None,\n system: Optional[str] = None,\n id: Union[str, UUID] = uuid4(),\n prime: bool = True,\n default_session: bool = True,\n console: bool = False,\n ai_text_color: Optional[str] = None,\n display_names: bool = True,\n **kwargs,\n ):\n \"\"\"\n Initialize a chatbot agent.\n\n Args:\n character (str, optional): The name of the chatbot for console display.\n Defaults to None.\n system (str, optional): System prompt for chatbot message.\n If None is provided it defaults to \"You are a helpful assistant.\"\n id (Union[str, UUID], optional): Initial session ID of the chatbot.\n Defaults to uuid4().\n prime (bool, optional): Whether to prime the chatbot with initial messages.\n Defaults to True.\n default_session (bool, optional): Whether to create a default chat session.\n Defaults to True.\n console (bool, optional): Whether to enable interactive console mode.\n Defaults to False.\n ai_text_color (str, optional): Print color of the chatbot's messages.\n display_names (bool, optional):\n Whether to display character names in the console.\n **kwargs: Additional options to pass to the `new_session` method.\n To customize GPT options, pass a `llm_options` dictionary.\n \"\"\"\n system_format = self.build_system(system)\n sessions = {}\n new_default_session = None\n super().__init__(default_session=new_default_session, sessions=sessions)\n\n if character:\n self.character = character\n if ai_text_color:\n self.ai_text_color = ai_text_color\n if default_session:\n new_default_session = self.new_session(\n set_default=True, system=system_format, id=id, **kwargs\n )\n if console:\n if not new_default_session:\n raise ValueError(\n \"A default session needs to exists to run in interactive mode.\"\n )\n new_default_session.title = character\n # print(kwargs)\n self.interactive_console(\n character=self.character,\n prime=prime,\n display_names=display_names,\n prompt=kwargs[\"prompt\"] if \"prompt\" in kwargs else None,\n )\n\n def new_session(\n self,\n set_default: bool = True,\n **kwargs,\n ) -> ChatLLMSession:\n \"\"\"\n Create a new chat session.\n\n Args:\n set_default (bool, optional): Whether to set the new session as the default.\n Defaults to True.\n **kwargs: Additional options to pass to the `ChatLLMSession` constructor.\n \"\"\"\n sess = ChatLLMSession(**kwargs)\n self.sessions[sess.id] = sess\n if set_default:\n self.default_session = sess\n return sess\n\n def get_session(self, id: Optional[Union[str, UUID]] = None) -> ChatLLMSession:\n \"\"\"\n Get a chat session by ID. If no ID is provided, return the default session.\n \"\"\"\n try:\n sess = self.sessions[id] if id else self.default_session\n except KeyError:\n raise KeyError(\"No session by that key exists.\")\n if not sess:\n raise ValueError(\"No default session exists.\")\n return sess\n\n def list_sessions(self) -> list[Union[str, UUID]]:\n \"\"\"\n List all session IDs.\n \"\"\"\n return list(self.sessions.keys())\n\n def reset_session(self, id: Optional[Union[str, UUID]] = None) -> None:\n \"\"\"\n Reset a chat session by ID.\n \"\"\"\n sess = self.get_session(id)\n sess.messages = []\n\n def delete_session(self, id: Optional[Union[str, UUID]] = None) -> None:\n \"\"\"\n Delete a chat session by ID.\n \"\"\"\n sess = self.get_session(id)\n if self.default_session:\n if sess.id == self.default_session.id:\n self.default_session = None\n del self.sessions[sess.id]\n del sess\n\n @contextmanager\n def session(self, **kwargs):\n sess = self.new_session(set_default=True, **kwargs)\n try:\n yield sess\n finally:\n self.delete_session(sess.id)\n\n def __call__(\n self,\n prompt: Union[str, Any],\n id: Optional[Union[str, UUID]] = None,\n system: Optional[str] = None,\n save_messages: Optional[bool] = None,\n llm_options: Optional[LLMOptions] = None,\n console_output: bool = False,\n ) -> str:\n \"\"\"\n Generate a response from the AI.\n \"\"\"\n sess = self.get_session(id)\n if console_output:\n console = Console(highlight=False, force_jupyter=False)\n ai_text_color = self.ai_text_color\n console.print(f\"[b]{self.character}[/b]: \", end=\"\", style=ai_text_color)\n stream = sess.stream(\n prompt,\n system=system,\n save_messages=save_messages,\n llm_options=llm_options,\n )\n for chunk in stream:\n console.print(chunk[\"delta\"], end=\"\", style=ai_text_color)\n console.print()\n return chunk[\"response\"] # type: ignore\n else:\n return sess.gen(\n prompt,\n system=system,\n save_messages=save_messages,\n llm_options=llm_options,\n )\n\n def stream(\n self,\n prompt: Union[str, Any],\n id: Optional[Union[str, UUID]] = None,\n system: Optional[str] = None,\n save_messages: Optional[bool] = None,\n llm_options: Optional[LLMOptions] = None,\n ):\n \"\"\"\n Generate a response from the AI.\n \"\"\"\n sess = self.get_session(id)\n return sess.stream(\n prompt,\n system=system,\n save_messages=save_messages,\n llm_options=llm_options,\n )\n\n def gen_model(\n self,\n prompt: Union[str, Any],\n response_model: Type[T],\n id: Optional[Union[str, UUID]] = None,\n system: Optional[str] = None,\n llm_options: Optional[LLMOptions] = None,\n ):\n \"\"\"\n Generate a pydantic typed model from the AI.\n \"\"\"\n sess = self.get_session(id)\n return sess.gen_model(\n prompt,\n response_model,\n system=system,\n llm_options=llm_options,\n )\n\n def build_system(self, system: Optional[str] = None) -> str:\n default = \"You are a helpful assistant.\"\n if system:\n return system\n else:\n return default\n\n def interactive_console(\n self,\n character: Optional[str] = None,\n prime: bool = True,\n prompt: Optional[str] = None,\n display_names: bool = True,\n ) -> None:\n \"\"\"\n Start an interactive console for the chatbot.\n \"\"\"\n console = Console(highlight=False, force_jupyter=False)\n sess = self.default_session\n ai_text_color = self.ai_text_color\n user_prompt_suffix = \"[b]You:[/b]\" if display_names else \"> \"\n agent_prompt_suffix = (\n f\"[b]{character}[/b]: \" if display_names and character else \"\"\n )\n\n if not sess:\n raise ValueError(\"No default session exists.\")\n\n # prime with a unique starting response to the user\n if prime:\n console.print(agent_prompt_suffix, end=\"\", style=ai_text_color)\n for chunk in sess.stream(\"Hello!\"):\n console.print(chunk[\"delta\"], end=\"\", style=ai_text_color)\n\n start = True\n while True:\n console.print()\n try:\n user_input = (\n prompt\n if start and prompt\n else console.input(user_prompt_suffix).strip()\n )\n start = False\n if not user_input:\n break\n\n console.print(agent_prompt_suffix, end=\"\", style=ai_text_color)\n for chunk in sess.stream(user_input):\n console.print(chunk[\"delta\"], end=\"\", style=ai_text_color)\n except KeyboardInterrupt:\n break\n\n def __str__(self) -> str | None:\n if self.default_session:\n return self.default_session.model_dump_json(exclude_none=True, indent=2)\n\n def __repr__(self) -> str:\n return \"\"\n\n def save_session(\n self,\n output_path: Optional[str] = None,\n id: Optional[Union[str, UUID]] = None,\n format: str = \"csv\",\n ):\n sess = self.get_session(id)\n sess_dict = sess.model_dump(\n exclude_none=True,\n )\n output_path = output_path or f\"chat_session.{format}\"\n if format == \"csv\":\n with open(output_path, \"w\", encoding=\"utf-8\") as f:\n fields = [\n \"role\",\n \"content\",\n \"received_at\",\n \"prompt_length\",\n \"completion_length\",\n \"total_length\",\n \"finish_reason\",\n ]\n w = csv.DictWriter(f, fieldnames=fields)\n w.writeheader()\n for message in sess_dict[\"messages\"]:\n # datetime must be in common format to be loaded into spreadsheet\n # for human-readability, the timezone is set to local machine\n local_datetime = message[\"received_at\"].astimezone()\n message[\"received_at\"] = local_datetime.strftime(\n \"%Y-%m-%d %H:%M:%S\"\n )\n w.writerow(message)\n elif format == \"json\":\n with open(output_path, \"w\") as f:\n f.write(sess.model_dump_json(exclude_none=True))\n\n def load_session(self, input_path: str, id: Union[str, UUID] = uuid4(), **kwargs):\n assert input_path.endswith(\".csv\") or input_path.endswith(\n \".json\"\n ), \"Only CSV and JSON imports are accepted.\"\n\n if input_path.endswith(\".csv\"):\n with open(input_path, \"r\", encoding=\"utf-8\") as f:\n r = csv.DictReader(f)\n messages = []\n for row in r:\n # need to convert the datetime back to UTC\n local_datetime = datetime.datetime.strptime(\n row[\"received_at\"], \"%Y-%m-%d %H:%M:%S\"\n ).replace(tzinfo=tz.tzlocal())\n row[\"received_at\"] = local_datetime.astimezone(\n datetime.timezone.utc\n )\n # https://stackoverflow.com/a/68305271\n row = {k: (None if v == \"\" else v) for k, v in row.items()}\n messages.append(ChatMessage(**row)) # type: ignore\n\n sess = self.new_session(id=id, **kwargs)\n sess.messages = messages\n return sess\n\n if input_path.endswith(\".json\"):\n with open(input_path, \"r\") as f:\n sess_dict = json.loads(f.read())\n # update session with info not loaded, e.g. auth/api_url\n for arg in kwargs:\n sess_dict[arg] = kwargs[arg]\n sess = self.new_session(**sess_dict)\n return sess\n\n # Tabulators for returning total token counts\n def message_totals(self, attr: str, id: Optional[Union[str, UUID]] = None) -> int:\n sess = self.get_session(id)\n return getattr(sess, attr)\n\n @property\n def total_prompt_length(self, id: Optional[Union[str, UUID]] = None) -> int:\n return self.message_totals(\"total_prompt_length\", id)\n\n @property\n def total_completion_length(self, id: Optional[Union[str, UUID]] = None) -> int:\n return self.message_totals(\"total_completion_length\", id)\n\n @property\n def total_length(self, id: Optional[Union[str, UUID]] = None) -> int:\n return self.message_totals(\"total_length\", id)\n\n # alias total_tokens to total_length for common use\n @property\n def total_tokens(self, id: Optional[Union[str, UUID]] = None) -> int:\n return self.total_length(id) # type: ignore" }, { "identifier": "SYSTEM_PROMPT", "path": "simple_ai_agents/prompts.py", "snippet": "SYSTEM_PROMPT = \"You are a helpful assistant.\"" } ]

[ { "identifier": "DatasetPannuke", "path": "data/pannuke_distillation_dataset.py", "snippet": "class DatasetPannuke(Dataset):\n \"\"\"\n Distillaton pannuke dataset\n \"\"\"\n\n def __init__(self, path: str, mode: str = 'train', true_labels: bool = False,\n hovernet_predictions: bool = True):\n \"\"\"\n :param path: path of processed pannuke dataset, h5 file\n :param mode: train or infer\n :param true_labels: load ground truth\n :param hovernet_predictions: load hovernet predictions\n \"\"\"\n assert isinstance(path, str), \"path have be instance of string\"\n assert isinstance(mode, str) and mode in ['train', 'infer'], \"mode must be either train or infer\"\n assert isinstance(hovernet_predictions, bool) and isinstance(true_labels, bool) and (\n hovernet_predictions or true_labels), \\\n \"hovernet_predictions and true_labels must be boolean, and at least one must be true\"\n\n self.path = path\n self.input_shape = (256, 256)\n self.output_shape = (256, 256)\n self.nr_types = 6\n self.mode = mode\n self.true_labels = true_labels\n self.hovernet_predictions = hovernet_predictions\n data = h5py.File(path, 'r')\n self.images = data['images']\n if mode == 'infer':\n self.types = data['types']\n if true_labels:\n self.labels = data['true_labels']\n if hovernet_predictions:\n self.hovernet = data['hovernet_predictions']\n\n def __len__(self):\n return len(self.images)\n\n def __getitem__(self, idx: int):\n outputs = ((self.images[idx] / 255).astype('float32'),)\n if self.mode == 'train':\n if self.true_labels:\n outputs += (self.labels[idx].astype('float32'),)\n if self.hovernet_predictions:\n outputs += (self.hovernet[idx].astype('float32'),)\n if len(outputs) == 3:\n outputs = (outputs[0], np.concatenate(outputs[1:], axis=-1))\n elif self.mode == 'infer':\n outputs += ('%s_%s' % (idx, self.types[idx].decode('utf8')),)\n\n return outputs" }, { "identifier": "process", "path": "models/HoVerNet/post_proc.py", "snippet": "def process(pred_map, nr_types=None, return_centroids=False):\n \"\"\"Post processing script for image tiles.\n\n Args:\n pred_map: commbined output of tp, np and hv branches, in the same order\n nr_types: number of types considered at output of nc branch\n overlaid_img: img to overlay the predicted instances upon, `None` means no\n type_colour (dict) : `None` to use random, else overlay instances of a type to colour in the dict\n output_dtype: data type of output\n \n Returns:\n pred_inst: pixel-wise nuclear instance segmentation prediction\n pred_type_out: pixel-wise nuclear type prediction \n\n \"\"\"\n if nr_types is not None:\n pred_type = pred_map[..., :1]\n pred_inst = pred_map[..., 1:]\n pred_type = pred_type.astype(np.int32)\n else:\n pred_inst = pred_map\n\n pred_inst = np.squeeze(pred_inst)\n pred_inst = __proc_np_hv(pred_inst)\n\n inst_info_dict = None\n if return_centroids or nr_types is not None:\n inst_id_list = np.unique(pred_inst)[1:] # exlcude background\n inst_info_dict = {}\n for inst_id in inst_id_list:\n inst_map = pred_inst == inst_id\n # TODO: chane format of bbox output\n rmin, rmax, cmin, cmax = get_bounding_box(inst_map)\n inst_bbox = np.array([[rmin, cmin], [rmax, cmax]])\n inst_map = inst_map[\n inst_bbox[0][0]: inst_bbox[1][0], inst_bbox[0][1]: inst_bbox[1][1]\n ]\n inst_map = inst_map.astype(np.uint8)\n inst_moment = cv2.moments(inst_map)\n inst_contour = cv2.findContours(\n inst_map, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE\n )\n # * opencv protocol format may break\n inst_contour = np.squeeze(inst_contour[0][0].astype(\"int32\"))\n # < 3 points dont make a contour, so skip, likely artifact too\n # as the contours obtained via approximation => too small or sthg\n if inst_contour.shape[0] < 3:\n continue\n if len(inst_contour.shape) != 2:\n continue # ! check for trickery shape\n inst_centroid = [\n (inst_moment[\"m10\"] / inst_moment[\"m00\"]),\n (inst_moment[\"m01\"] / inst_moment[\"m00\"]),\n ]\n inst_centroid = np.array(inst_centroid)\n inst_contour[:, 0] += inst_bbox[0][1] # X\n inst_contour[:, 1] += inst_bbox[0][0] # Y\n inst_centroid[0] += inst_bbox[0][1] # X\n inst_centroid[1] += inst_bbox[0][0] # Y\n inst_info_dict[inst_id] = { # inst_id should start at 1\n \"bbox\": inst_bbox,\n \"centroid\": inst_centroid,\n \"contour\": inst_contour,\n \"type_prob\": None,\n \"type\": None,\n }\n\n if nr_types is not None:\n #### * Get class of each instance id, stored at index id-1\n for inst_id in list(inst_info_dict.keys()):\n rmin, cmin, rmax, cmax = (inst_info_dict[inst_id][\"bbox\"]).flatten()\n inst_map_crop = pred_inst[rmin:rmax, cmin:cmax]\n inst_type_crop = pred_type[rmin:rmax, cmin:cmax]\n inst_map_crop = (\n inst_map_crop == inst_id\n ) # TODO: duplicated operation, may be expensive\n inst_type = inst_type_crop[inst_map_crop]\n type_list, type_pixels = np.unique(inst_type, return_counts=True)\n type_list = list(zip(type_list, type_pixels))\n type_list = sorted(type_list, key=lambda x: x[1], reverse=True)\n inst_type = type_list[0][0]\n if inst_type == 0: # ! pick the 2nd most dominant if exist\n if len(type_list) > 1:\n inst_type = type_list[1][0]\n type_dict = {v[0]: v[1] for v in type_list}\n type_prob = type_dict[inst_type] / (np.sum(inst_map_crop) + 1.0e-6)\n inst_info_dict[inst_id][\"type\"] = int(inst_type)\n if inst_type not in [0,1,2,3,4,5]:\n pass\n inst_info_dict[inst_id][\"type_prob\"] = float(type_prob)\n\n # print('here')\n # ! WARNING: ID MAY NOT BE CONTIGUOUS\n # inst_id in the dict maps to the same value in the `pred_inst`\n return pred_inst, inst_info_dict" } ]

[ { "identifier": "ShaderProgram", "path": "shader_program.py", "snippet": "class ShaderProgram:\n def __init__(self, renderer):\n self.app = renderer.app\n self.ctx = renderer.ctx\n self.camera = renderer.camera\n\n # -------- shaders -------- #\n self.axis = self.get_program(shader_name='axis')\n self.point_cloud = self.get_program(shader_name='point_cloud')\n\n # UBO structure:\n #\n # mat4 m_proj == 64 bytes\n # vec3 center == 12\n # float rot_speed == 4\n # mat4 m_view == 64\n # vec3 cam_pos == 12\n # float u_time == 4\n\n self.ubo_bytes = {\n 'm_proj': 64,\n 'center': 12,\n 'rot_speed': 4,\n 'm_view': 64,\n 'cam_pos': 12,\n 'u_time': 4\n }\n\n # offsets\n self.offsets = dict(zip(\n self.ubo_bytes, accumulate(self.ubo_bytes.values(), initial=0)))\n\n # get buffer size\n min_size = sum(self.ubo_bytes.values())\n buffer_size = min_size if not min_size % 16 else ((min_size // 16) + 1) * 16\n # padding = buffer_size - min_size\n\n # ubo\n self.uniform_buffer = self.ctx.buffer(reserve=buffer_size)\n self.uniform_buffer.bind_to_uniform_block(binding=UBO_BIND_VALUE)\n\n # binding\n self.axis['UBO'].binding = UBO_BIND_VALUE\n\n self.set_uniforms_on_init()\n\n def set_uniforms_on_init(self):\n #\n self.uniform_buffer.write(\n data=self.camera.m_proj, offset=self.offsets['m_proj'])\n #\n self.uniform_buffer.write(\n data=self.app.data_loader.center, offset=self.offsets['center'])\n #\n self.uniform_buffer.write(\n data=struct.pack('=1f', WORLD_ROT_SPEED), offset=self.offsets['rot_speed'])\n\n def update(self):\n #\n self.uniform_buffer.write(\n data=self.camera.m_view, offset=self.offsets['m_view'])\n #\n self.uniform_buffer.write(\n data=self.camera.position, offset=self.offsets['cam_pos'])\n #\n self.uniform_buffer.write(\n data=struct.pack('=1f', self.app.time), offset=self.offsets['u_time'])\n\n def get_program(self, shader_name):\n with open(f'shaders/{shader_name}.vert') as file:\n vertex_shader = file.read()\n\n with open(f'shaders/{shader_name}.frag') as file:\n fragment_shader = file.read()\n\n program = self.ctx.program(vertex_shader=vertex_shader, fragment_shader=fragment_shader)\n return program" }, { "identifier": "Camera", "path": "camera.py", "snippet": "class Camera:\n def __init__(self, app, position=INIT_CAM_POS, yaw=INIT_CAM_YAW, pitch=INIT_CAM_PITCH):\n self.app = app\n\n self.position = glm.vec3(position)\n self.yaw = glm.radians(yaw)\n self.pitch = glm.radians(pitch)\n\n self.up = glm.vec3(0, 1, 0)\n self.right = glm.vec3(1, 0, 0)\n self.forward = glm.vec3(0, 0, -1)\n\n self.m_proj = glm.perspective(V_FOV, ASPECT_RATIO, NEAR, FAR)\n self.m_view = glm.mat4()\n\n def mouse_control(self):\n mouse_dx, mouse_dy = pg.mouse.get_rel()\n if mouse_dx:\n self.rotate_yaw(delta_x=mouse_dx * MOUSE_SENSITIVITY)\n if mouse_dy:\n self.rotate_pitch(delta_y=mouse_dy * MOUSE_SENSITIVITY)\n\n def keyboard_control(self):\n key_state = pg.key.get_pressed()\n vel = CAM_SPEED * self.app.delta_time\n next_step = glm.vec3()\n #\n if key_state[KEYS['FORWARD']]:\n next_step += self.move_forward(vel)\n if key_state[KEYS['BACK']]:\n next_step += self.move_back(vel)\n if key_state[KEYS['STRAFE_R']]:\n next_step += self.move_right(vel)\n if key_state[KEYS['STRAFE_L']]:\n next_step += self.move_left(vel)\n #\n if key_state[KEYS['UP']]:\n self.move_up(vel)\n if key_state[KEYS['DOWN']]:\n self.move_down(vel)\n #\n self.position += next_step\n\n def update(self):\n self.keyboard_control()\n self.mouse_control()\n #\n self.update_vectors()\n self.update_view_matrix()\n\n def update_view_matrix(self):\n self.m_view = glm.lookAt(self.position, self.position + self.forward, self.up)\n\n def update_vectors(self):\n self.forward.x = glm.cos(self.yaw) * glm.cos(self.pitch)\n self.forward.y = glm.sin(self.pitch)\n self.forward.z = glm.sin(self.yaw) * glm.cos(self.pitch)\n\n self.forward = glm.normalize(self.forward)\n self.right = glm.normalize(glm.cross(self.forward, glm.vec3(0, 1, 0)))\n self.up = glm.normalize(glm.cross(self.right, self.forward))\n\n def rotate_pitch(self, delta_y):\n self.pitch -= delta_y\n self.pitch = glm.clamp(self.pitch, -PITCH_MAX, PITCH_MAX)\n\n def rotate_yaw(self, delta_x):\n self.yaw += delta_x\n\n def move_left(self, velocity):\n return -self.right * velocity\n\n def move_right(self, velocity):\n return self.right * velocity\n\n def move_up(self, velocity):\n self.position += self.up * velocity\n\n def move_down(self, velocity):\n self.position -= self.up * velocity\n\n def move_forward(self, velocity):\n return self.forward * velocity\n\n def move_back(self, velocity):\n return -self.forward * velocity" }, { "identifier": "PointCloudMesh", "path": "meshes/point_cloud_mesh.py", "snippet": "class PointCloudMesh:\n def __init__(self, renderer):\n self.ctx = renderer.ctx\n self.program = renderer.shader_program.point_cloud\n self.data_loader = renderer.app.data_loader\n #\n self.vao = self.get_vao()\n\n def get_vao(self):\n point_position_buffer = self.ctx.buffer(self.data_loader.point_positions)\n point_prime_flag_buffer = self.ctx.buffer(self.data_loader.prime_flags)\n #\n vao = self.ctx.vertex_array(\n self.program,\n [\n (point_position_buffer, '3f', 'in_position'),\n (point_prime_flag_buffer, '1i1', 'is_prime'),\n ],\n skip_errors=True\n )\n return vao\n\n def render(self):\n self.vao.render(mode=mgl.POINTS)" }, { "identifier": "AxisMesh", "path": "meshes/axis_mesh.py", "snippet": "class AxisMesh:\n def __init__(self, renderer, scale=1.0, center=glm.vec3(0.0)):\n self.ctx = renderer.ctx\n self.program = renderer.shader_program.axis\n\n self.scale = scale * 0.85\n self.center = center\n\n self.vbo_format = '3f'\n self.vbo_attrs = ('in_position',)\n self.vao = self.get_vao()\n\n def get_vao(self):\n vertex_data = self.get_vertex_data()\n vbo = self.ctx.buffer(vertex_data)\n vao = self.ctx.vertex_array(\n self.program, [\n (vbo, self.vbo_format, *self.vbo_attrs)\n ],\n skip_errors=True\n )\n return vao\n\n def render(self):\n self.vao.render(mgl.LINES)\n\n def get_vertex_data(self):\n vert_data = np.array(\n [[-1, 0, 0], [1, 0, 0],\n [0, 0, 1], [0, 0, -1],\n [0, -1, 0], [0, 1, 0],], dtype='float32')\n\n vert_data = vert_data * self.scale + self.center\n return vert_data" } ]

[ { "identifier": "WeightsManager", "path": "weights_manager.py", "snippet": "class WeightsManager:\n def __init__(self, predictor):\n self.predictor = predictor\n self.weights_cache = WeightsDownloadCache()\n\n def load_trained_weights(self, weights, pipe):\n from no_init import no_init_or_tensor\n\n # weights can be a URLPath, which behaves in unexpected ways\n weights = str(weights)\n if self.predictor.tuned_weights == weights:\n print(\"skipping loading .. weights already loaded\")\n return\n\n self.predictor.tuned_weights = weights\n\n local_weights_cache = self.weights_cache.ensure(weights)\n\n # load UNET\n print(\"Loading fine-tuned model\")\n self.predictor.is_lora = False\n\n maybe_unet_path = os.path.join(local_weights_cache, \"unet.safetensors\")\n if not os.path.exists(maybe_unet_path):\n print(\"Does not have Unet. assume we are using LoRA\")\n self.predictor.is_lora = True\n\n if not self.predictor.is_lora:\n print(\"Loading Unet\")\n\n new_unet_params = load_file(\n os.path.join(local_weights_cache, \"unet.safetensors\")\n )\n # this should return _IncompatibleKeys(missing_keys=[...], unexpected_keys=[])\n pipe.unet.load_state_dict(new_unet_params, strict=False)\n\n else:\n print(\"Loading Unet LoRA\")\n\n unet = pipe.unet\n\n tensors = load_file(os.path.join(local_weights_cache, \"lora.safetensors\"))\n\n unet_lora_attn_procs = {}\n name_rank_map = {}\n for tk, tv in tensors.items():\n # up is N, d\n if tk.endswith(\"up.weight\"):\n proc_name = \".\".join(tk.split(\".\")[:-3])\n r = tv.shape[1]\n name_rank_map[proc_name] = r\n\n for name, attn_processor in unet.attn_processors.items():\n cross_attention_dim = (\n None\n if name.endswith(\"attn1.processor\")\n else unet.config.cross_attention_dim\n )\n if name.startswith(\"mid_block\"):\n hidden_size = unet.config.block_out_channels[-1]\n elif name.startswith(\"up_blocks\"):\n block_id = int(name[len(\"up_blocks.\")])\n hidden_size = list(reversed(unet.config.block_out_channels))[\n block_id\n ]\n elif name.startswith(\"down_blocks\"):\n block_id = int(name[len(\"down_blocks.\")])\n hidden_size = unet.config.block_out_channels[block_id]\n with no_init_or_tensor():\n module = LoRAAttnProcessor2_0(\n hidden_size=hidden_size,\n cross_attention_dim=cross_attention_dim,\n rank=name_rank_map[name],\n )\n unet_lora_attn_procs[name] = module.to(\"cuda\", non_blocking=True)\n\n unet.set_attn_processor(unet_lora_attn_procs)\n unet.load_state_dict(tensors, strict=False)\n\n # load text\n handler = TokenEmbeddingsHandler(\n [pipe.text_encoder, pipe.text_encoder_2], [pipe.tokenizer, pipe.tokenizer_2]\n )\n handler.load_embeddings(os.path.join(local_weights_cache, \"embeddings.pti\"))\n\n # load params\n with open(os.path.join(local_weights_cache, \"special_params.json\"), \"r\") as f:\n params = json.load(f)\n self.predictor.token_map = params\n\n self.predictor.tuned_model = True" }, { "identifier": "WeightsDownloader", "path": "weights_downloader.py", "snippet": "class WeightsDownloader:\n @staticmethod\n def download_if_not_exists(url, dest):\n if not os.path.exists(dest):\n WeightsDownloader.download(url, dest)\n\n @staticmethod\n def download(url, dest):\n start = time.time()\n print(\"downloading url: \", url)\n print(\"downloading to: \", dest)\n subprocess.check_call([\"pget\", \"-x\", url, dest], close_fds=False)\n print(\"downloading took: \", time.time() - start)" }, { "identifier": "ControlNet", "path": "controlnet.py", "snippet": "class ControlNet:\n CONTROLNET_MODELS = [\n \"none\",\n \"edge_canny\",\n \"illusion\",\n \"depth_leres\",\n \"depth_midas\",\n \"soft_edge_pidi\",\n \"soft_edge_hed\",\n \"lineart\",\n \"lineart_anime\",\n \"openpose\",\n # Preprocessors without an XL model yet\n # \"straight_edge_mlsd\",\n # \"face_detector\",\n # \"content_shuffle\",\n # \"normal_bae\",\n # \"segementation_sam\",\n ]\n\n def __init__(self, predictor):\n WeightsDownloader.download_if_not_exists(CONTROLNET_URL, CONTROLNET_MODEL_CACHE)\n\n self.controlnet_preprocessor = ControlNetPreprocessor(predictor)\n self.models = {\n \"canny\": self.initialize_controlnet(\n \"diffusers/controlnet-canny-sdxl-1.0\",\n ),\n \"depth\": self.initialize_controlnet(\n \"diffusers/controlnet-depth-sdxl-1.0-small\",\n ),\n \"soft_edge\": self.initialize_controlnet(\n \"SargeZT/controlnet-sd-xl-1.0-softedge-dexined\",\n ),\n \"openpose\": self.initialize_controlnet(\n \"thibaud/controlnet-openpose-sdxl-1.0\",\n ),\n \"illusion\": self.initialize_controlnet(\n \"monster-labs/control_v1p_sdxl_qrcode_monster\",\n ),\n }\n\n def initialize_controlnet(self, model_name):\n print(\"Initializing\", model_name)\n return ControlNetModel.from_pretrained(\n model_name, cache_dir=CONTROLNET_MODEL_CACHE, torch_dtype=torch.float16\n )\n\n def get_model(self, controlnet_name):\n if controlnet_name in self.models:\n return self.models[controlnet_name]\n elif controlnet_name.startswith(\"edge_\"):\n return self.models[\"canny\"]\n elif controlnet_name.startswith(\"depth_\"):\n return self.models[\"depth\"]\n elif controlnet_name.startswith(\"soft_edge\") or controlnet_name.startswith(\n \"lineart\"\n ):\n return self.models[\"soft_edge\"]\n else:\n return None\n\n def get_models(self, controlnet_names):\n models = [\n self.get_model(controlnet_name) for controlnet_name in controlnet_names\n ]\n return list(filter(None, models))\n\n def preprocess(self, image, controlnet_name):\n # Illusion model needs no preprocessing\n if controlnet_name == \"illusion\" or controlnet_name == \"none\":\n return image\n\n return self.controlnet_preprocessor.process_image(image, controlnet_name)\n\n @staticmethod\n def get_controlnet_names():\n return ControlNet.CONTROLNET_MODELS" }, { "identifier": "SizingStrategy", "path": "sizing_strategy.py", "snippet": "class SizingStrategy:\n def __init__(self):\n pass\n\n def get_dimensions(self, image):\n original_width, original_height = image.size\n print(\n f\"Original dimensions: Width: {original_width}, Height: {original_height}\"\n )\n resized_width, resized_height = self.get_resized_dimensions(\n original_width, original_height\n )\n print(\n f\"Dimensions to resize to: Width: {resized_width}, Height: {resized_height}\"\n )\n return resized_width, resized_height\n\n def get_allowed_dimensions(self, base=LOWEST_DIMENSION, max_dim=MAX_DIMENSION):\n \"\"\"\n Function to generate allowed dimensions optimized around a base up to a max\n \"\"\"\n allowed_dimensions = []\n for i in range(base, max_dim + 1, 64):\n for j in range(base, max_dim + 1, 64):\n allowed_dimensions.append((i, j))\n return allowed_dimensions\n\n def get_resized_dimensions(self, width, height):\n allowed_dimensions = self.get_allowed_dimensions()\n aspect_ratio = width / height\n print(f\"Aspect Ratio: {aspect_ratio:.2f}\")\n # Find the closest allowed dimensions that maintain the aspect ratio\n # and are closest to the optimum dimension\n closest_dimensions = min(\n allowed_dimensions,\n key=lambda dim: abs(dim[0] / dim[1] - aspect_ratio)\n + abs(dim[0] - OPTIMUM_DIMENSION),\n )\n return closest_dimensions\n\n def resize_images(self, images, width, height):\n return [\n img.resize((width, height)) if img is not None else None for img in images\n ]\n\n def open_image(self, image_path):\n return Image.open(str(image_path)) if image_path is not None else None\n\n def apply(\n self,\n sizing_strategy,\n width,\n height,\n image=None,\n mask=None,\n control_1_image=None,\n control_2_image=None,\n control_3_image=None,\n ):\n image_dict = {\n \"input_image\": self.open_image(image),\n \"mask_image\": self.open_image(mask),\n \"controlnet_1_image\": self.open_image(control_1_image),\n \"controlnet_2_image\": self.open_image(control_2_image),\n \"controlnet_3_image\": self.open_image(control_3_image),\n }\n\n if sizing_strategy in image_dict:\n print(f\"Resizing based on {sizing_strategy}\")\n width, height = self.get_dimensions(image_dict[sizing_strategy])\n else:\n print(\"Using given dimensions\")\n\n resized_images = self.resize_images(\n list(image_dict.values()),\n width,\n height,\n )\n\n return width, height, resized_images" } ]

[ { "identifier": "NotFound", "path": "discord_http/errors.py", "snippet": "class NotFound(HTTPException):\n \"\"\" Raised whenever a HTTP request returns 404 \"\"\"\n pass" }, { "identifier": "DiscordServerError", "path": "discord_http/errors.py", "snippet": "class DiscordServerError(HTTPException):\n \"\"\" Raised whenever an unexpected HTTP error occurs \"\"\"\n pass" }, { "identifier": "Forbidden", "path": "discord_http/errors.py", "snippet": "class Forbidden(HTTPException):\n \"\"\" Raised whenever a HTTP request returns 403 \"\"\"\n pass" }, { "identifier": "HTTPException", "path": "discord_http/errors.py", "snippet": "class HTTPException(DiscordException):\n \"\"\" Base exception for HTTP requests \"\"\"\n def __init__(self, r: \"HTTPResponse\"):\n self.request = r\n self.status: int = r.status\n\n self.code: int\n self.text: str\n\n if isinstance(r.response, dict):\n self.code = r.response.get(\"code\", 0)\n self.text = r.response.get(\"message\", \"Unknown\")\n if r.response.get(\"errors\", None):\n self.text += f\"\\n{r.response['errors']}\"\n else:\n self.text: str = str(r.response)\n self.code = 0\n\n error_text = f\"HTTP {self.request.status} > {self.request.reason} (code: {self.code})\"\n if len(self.text):\n error_text += f\": {self.text}\"\n\n super().__init__(error_text)" } ]

[ { "identifier": "FourPLLogistic", "path": "bio_curve_fit/logistic.py", "snippet": "class FourPLLogistic(BaseEstimator, RegressorMixin, BaseStandardCurve):\n def __init__(\n self,\n A=None,\n B=None,\n C=None,\n D=None,\n LLOD=None,\n ULOD=None,\n ULOD_y=None,\n LLOD_y=None,\n slope_direction_positive: Optional[bool] = None,\n slope_guess_num_points_to_use: int = 3,\n ):\n # A is the minimum asymptote\n self.A_ = A\n # B is the Hill's slope\n self.B_ = B\n # C is the inflection point (EC50)\n self.C_ = C\n # D is the maximum asymptote\n self.D_ = D\n self.cov_ = None\n # Initial guesses used when fitting the curve\n self.guess_A_ = None\n self.guess_B_ = None\n self.guess_C_ = None\n self.guess_D_ = None\n # Estimated Limits of Detection for response signal\n self.LLOD_y_ = LLOD_y\n self.ULOD_y_ = ULOD_y\n # Estimated Limits of Detection for concentration\n self.LLOD_ = LLOD\n self.ULOD_ = ULOD\n self.slope_direction_positive = slope_direction_positive\n self.slope_guess_num_points_to_use = slope_guess_num_points_to_use\n\n def check_fit(self):\n if self.A_ is None or self.B_ is None or self.C_ is None or self.D_ is None:\n raise Exception(\n \"Model is not fit yet. Please call 'fit' with appropriate data\"\n \" or initialize the model object with non-null parameters.\"\n )\n\n def get_params(self, deep=False):\n if deep:\n return {\n \"A\": self.A_,\n \"B\": self.B_,\n \"C\": self.C_,\n \"D\": self.D_,\n \"LLOD\": self.LLOD_,\n \"ULOD\": self.ULOD_,\n \"ULOD_y\": self.ULOD_y_,\n \"LLOD_y\": self.LLOD_y_,\n }\n else:\n return {\n \"A\": self.A_,\n \"B\": self.B_,\n \"C\": self.C_,\n \"D\": self.D_,\n }\n\n @staticmethod\n def four_param_logistic(x, A, B, C, D):\n \"\"\"4 Parameter Logistic (4PL) model.\"\"\"\n\n # For addressing fractional powers of negative numbers\n # https://stackoverflow.com/questions/45384602/numpy-runtimewarning-invalid-value-encountered-in-power\n z = np.sign(x / C) * np.abs(x / C) ** B\n\n return ((A - D) / (1.0 + z)) + D\n\n @staticmethod\n def inverse_variance_weight_function(y_data):\n \"\"\"\n Function for weighting residuals by 1/y^2 in `scipy.optimize.curve_fit`.\n \"\"\"\n # To avoid division by zero, add a small constant to y_data.\n return y_data + np.finfo(float).eps\n\n def _calculate_lod_replicate_variance(\n self,\n x_data,\n y_data,\n lower_std_dev_multiplier: float = 2.5,\n upper_std_dev_multiplier: float = 0.0,\n ):\n \"\"\"\n Calculate the Lower and Upper Limits of Detection (LLOD and ULOD) using variance\n of replicate max and min concentration standards. It ignore zero concentration\n standards. If there are no replicates, the standard deviation zero\n Possible TODO: sometimes a minimum variance is used in other software.\n\n In the notation below we assume the response signal is the Y-axis and the\n concentration is the X-axis.\n\n Example: Two replicates of the lowest concentration standard (conc=1.0 pg/ml)\n have standard deviation of 100 across their responses. LLOD will be `model.predict\n (1.0) + 100 * 2.5` where 2.5 is the `lower_std_dev_multiplier` parameter.\n\n :param bottom_std_dev: Standard deviation at the bottom calibration point.\n :param top_std_dev: Standard deviation at the top calibration point.\n :param std_dev_multiplier: Multiplier for the standard deviations (default 2.5).\n :return: Pair of tuples containing the LLOD and ULOD, and the corresponding x-values.\n \"\"\"\n\n x_indexed_y_data = pd.DataFrame({\"x\": x_data, \"y\": y_data}).set_index(\"x\")\n # remove zeros from x_data\n x_indexed_y_data = x_indexed_y_data[x_indexed_y_data.index > 0]\n x_min = np.min(x_indexed_y_data.index)\n x_max = np.max(x_indexed_y_data.index)\n bottom_std_dev = x_indexed_y_data.loc[x_min, \"y\"].std()\n top_std_dev = x_indexed_y_data.loc[x_max, \"y\"].std()\n\n # Calculate LLOD and ULOD of RESPONSE SIGNAL\n llod = self.predict(x_min) + (lower_std_dev_multiplier * bottom_std_dev)\n ulod = self.predict(x_max) - (upper_std_dev_multiplier * top_std_dev)\n\n # Calculate the limits of detection for CONCENTRATION\n llod_x = self.predict_inverse(llod)\n ulod_x = self.predict_inverse(ulod)\n return llod_x, ulod_x, llod, ulod\n\n def fit(self, x_data, y_data, weight_func=None, LOD_func=None, **kwargs):\n \"\"\"\n Fit the 4 Parameter Logistic (4PL) model.\n\n x_data: x data points\n y_data: y data points\n weight_func: optional Function that calculates weights from y_data. This is\n passed into the `curve_fit` function where the function minimized is `sum\n ((r / weight_func(y_data)) ** 2)` where r is the residuals.\n Thus for a typical 1/y^2 weighting, `weight_func` should be `lambda\n y_data: y_data`\n \"\"\"\n x_data = np.float64(x_data)\n y_data = np.float64(y_data)\n df_data = pd.DataFrame({\"x\": x_data, \"y\": y_data})\n df_data.sort_values(by=\"x\", inplace=True)\n\n if LOD_func is None:\n # default LOD_func is to use replicate variance\n LOD_func = self._calculate_lod_replicate_variance\n\n absolute_sigma = False\n weights = None\n if weight_func is not None:\n weights = weight_func(y_data)\n absolute_sigma = True\n\n # Initial guess for the parameters\n self.guess_A_ = np.min(y_data) # type: ignore\n if self.slope_direction_positive is not None:\n self.guess_B_ = 1.0 if self.slope_direction_positive else -1.0\n else:\n # type: ignore\n self.guess_B_ = (\n 1.0\n if np.mean(\n df_data.iloc[: np.minimum(self.slope_guess_num_points_to_use, len(df_data))][ # type: ignore\n \"y\"\n ]\n )\n < np.mean(\n df_data.iloc[-np.minimum(self.slope_guess_num_points_to_use, len(df_data)) :][ # type: ignore\n \"y\"\n ]\n )\n else -1.0\n )\n self.guess_C_ = np.mean(x_data) # type: ignore\n self.guess_D_ = np.max(y_data) # type: ignore\n initial_guess = [self.guess_A_, self.guess_B_, self.guess_C_, self.guess_D_]\n\n curve_fit_kwargs = {\n \"f\": self.four_param_logistic,\n \"xdata\": x_data,\n \"ydata\": y_data,\n \"p0\": initial_guess,\n \"maxfev\": 10000,\n \"sigma\": weights,\n \"absolute_sigma\": absolute_sigma,\n }\n\n # overwrite parameters with any kwargs passed in\n for k, v in kwargs.items():\n curve_fit_kwargs[k] = v\n\n # Perform the curve fit\n params, cov = curve_fit(**curve_fit_kwargs)\n self.A_, self.B_, self.C_, self.D_ = params\n self.cov_ = cov\n self.LLOD_, self.ULOD_, self.LLOD_y_, self.ULOD_y_ = LOD_func(x_data, y_data)\n return self\n\n @staticmethod\n def jacobian(x_data, A, B, C, D):\n \"\"\"\n Jacobian matrix of the 4PL function with respect to A, B, C, D.\n \"\"\"\n z = (x_data / C) ** B\n\n partial_A = 1.0 / (1.0 + z)\n partial_B = -(z * (A - D) * np.log(np.maximum(x_data / C, np.finfo(float).eps))) / ( # type: ignore\n (1.0 + z) ** 2\n )\n partial_C = (B * z * (A - D)) / (C * (1.0 + z) ** 2)\n partial_D = 1.0 - 1.0 / (1.0 + z)\n\n # Jacobian matrix\n J = np.array([partial_A, partial_B, partial_C, partial_D]).T\n return J\n\n def predict_confidence_band(self, x_data):\n \"\"\"\n Predict confidence bands of data points.\n\n See:\n https://www.graphpad.com/guides/prism/latest/curve-fitting/reg_graphing_confidence_and_predic.htm\n https://www.graphpad.com/guides/prism/latest/curve-fitting/reg_how_confidence_and_prediction_.htm\n https://stats.stackexchange.com/questions/15423/how-to-compute-prediction-bands-for-non-linear-regression\n\n \"\"\"\n if self.cov_ is None:\n raise Exception(\n \"Covariance matrix is not available. Please call 'fit' with appropriate data.\"\n )\n J = self.jacobian(x_data, self.A_, self.B_, self.C_, self.D_)\n pred_var = np.sum((J @ self.cov_) * J, axis=1)\n\n return np.sqrt(pred_var)\n\n def predict_prediction_band(self, x_data, y_data):\n \"\"\"\n Predict prediction bands of data points.\n TODO: still need to double-check the math here.\n \"\"\"\n ss = (y_data - self.predict(x_data)) ** 2\n df = len(x_data) - 4 # 4 parameters\n\n return np.sqrt(self.predict_confidence_band(x_data) ** 2 * ss / df)\n\n def predict_inverse(self, y):\n \"\"\"Inverse 4 Parameter Logistic (4PL) model.\n\n Used for calculating the x-value for a given y-value.\n Usually, standard curves are fitted using concentration as x-values and response as\n y-values, so that variance in response is modeled for a given known concentration.\n But for samples of unknown concentration, we want to get the concentration as given\n response, which is what this function does.\n\n \"\"\"\n self.check_fit()\n z = ((self.A_ - self.D_) / (y - self.D_)) - 1 # type: ignore\n\n # For addressing fractional powers of negative numbers, np.sign(z) * np.abs(z) used rather than z\n # https://stackoverflow.com/questions/45384602/numpy-runtimewarning-invalid-value-encountered-in-power\n return self.C_ * (np.sign(z) * np.abs(z) ** (1 / self.B_)) # type: ignore\n\n def predict(self, x_data):\n self.check_fit()\n return self.four_param_logistic(x_data, self.A_, self.B_, self.C_, self.D_)" }, { "identifier": "plot_standard_curve", "path": "bio_curve_fit/plotting.py", "snippet": "def plot_standard_curve(\n x_data,\n y_data,\n fitted_model: BaseStandardCurve,\n title=\"Standard Curve Fit\",\n x_label=\"Concentration\",\n y_label=\"Response\",\n show_plot: bool = False,\n) -> bytes:\n \"\"\"\n Generate a plot of the data and the fitted curve.\n \"\"\"\n # Plot the data and the fitted curve\n # set x-axis to log scale\n # set scales to log\n plt.xscale(\"log\")\n plt.yscale(\"log\")\n data = pd.DataFrame({\"x\": x_data, \"y\": y_data})\n # remove zeros from x_data\n filtered_data = data[data[\"x\"] > 0]\n\n # Plot the fitted curve\n epsilon = 0.01\n x_min = np.log10(max(min(x_data), epsilon))\n x_max = max(x_data) * 2\n x = np.logspace(x_min, np.log10(x_max), 100) # type: ignore\n # Generate y-data based on the fitted parameters\n y_pred = fitted_model.predict(x)\n\n plt.plot(x, y_pred, label=\"Fitted curve\", color=\"red\")\n plt.scatter(filtered_data[\"x\"], filtered_data[\"y\"], label=\"Data\", s=12)\n formatter = ScalarFormatter()\n formatter.set_scientific(False)\n plt.gca().xaxis.set_major_formatter(formatter)\n plt.xlabel(x_label)\n plt.ylabel(y_label)\n plt.title(title)\n\n # set horizontal and vertical lines for ULOD and LLOD\n llod_response, ulod_response = fitted_model.LLOD_y_, fitted_model.ULOD_y_\n plt.axhline(llod_response, color=\"red\", linestyle=\"--\", label=\"LLOD\") # type: ignore\n plt.axhline(ulod_response, color=\"blue\", linestyle=\"--\", label=\"ULOD\") # type: ignore\n plt.legend()\n if show_plot:\n plt.show()\n # Save the plot to a BytesIO object\n buf = io.BytesIO()\n plt.savefig(buf, format=\"png\")\n plt.clf()\n buf.seek(0)\n return buf.read()" } ]

[ { "identifier": "BackboneDecisionTree", "path": "backbone_learn/backbone/backbone_decision_tree.py", "snippet": "class BackboneDecisionTree(BackboneSupervised):\n \"\"\"\n Specific implementation of the Backbone method for sparse regression.\n\n This class combines Pearson correlation for feature screening, L0BnB for exact solving, and Lasso for heuristic solving to construct a sparse regression model.\n\n Inherits from:\n BackboneBase (ABC): The abstract base class for backbone algorithms.\n \"\"\"\n\n def set_solvers(\n self,\n alpha=0.5,\n depth=3,\n time_limit=1000,\n _lambda=0.5,\n num_threads=None,\n obj_mode=\"acc\",\n n_bins=2,\n is_data_fit=False,\n ):\n \"\"\"\n Initializes the sparse regression method with specified components.\n\n Args:\n alpha (float): Proportion of features to retain after screening. Defaults to 0.5.\n depth (int, optional): Depth of BendersOCT tree. Defaults to 3.\n time_limit (int): Time limit for the optimization process.\n _lambda (float): Regularization parameter.\n num_threads (int or None): Number of threads for parallel processing.\n obj_mode (str): Objective mode, e.g., 'acc' for accuracy.\n n_bins (int): Number of bins for KBinsDiscretizer. Defaults to 2.\n is_data_fit (bool): Whether data are in the format required for OCT\n \"\"\"\n self.screen_selector = PearsonCorrelationSelector(alpha)\n self.exact_solver = BendersOCTDecisionTree(\n depth=depth,\n time_limit=time_limit,\n _lambda=_lambda,\n num_threads=num_threads,\n obj_mode=obj_mode,\n n_bins=n_bins,\n is_data_fit=is_data_fit,\n )\n self.heuristic_solver = CARTDecisionTree()" }, { "identifier": "CARTDecisionTree", "path": "backbone_learn/heuristic_solvers/cart_decision_tree.py", "snippet": "class CARTDecisionTree(HeuristicSolverBase):\n \"\"\"\n Implements a Classification And Regression Tree (CART) Decision Tree with cross-validation using AUC.\n This solver is a heuristic approach for fitting a decision tree model and identifying significant features.\n\n Attributes:\n _model (DecisionTreeClassifier): An instance of the sklearn DecisionTreeClassifier.\n _auc_score (float): The maximum AUC score obtained during cross-validation.\n \"\"\"\n\n def __init__(self, **kwargs):\n \"\"\"\n Initializes the CARTDecisionTree with a DecisionTreeClassifier model.\n \"\"\"\n self._model = DecisionTreeClassifier()\n self._auc_score = None\n\n @property\n def auc_score(self) -> float:\n \"\"\"\n Returns the maximum AUC score obtained from cross-validation.\n\n Returns:\n float: The maximum AUC score.\n \"\"\"\n return self._auc_score\n\n def fit(self, X: np.ndarray, y: np.ndarray, cv_folds: int = 5, random_state: int = 0) -> None:\n \"\"\"\n Fits a CART Decision Tree model to the data using hyperparameter tuning with cross-validation and evaluates it using AUC.\n\n Args:\n X (np.ndarray): The input features as a NumPy array.\n y (np.ndarray): The target labels as a NumPy array.\n cv_folds (int): The number of folds to use for cross-validation.\n\n \"\"\"\n self._model.set_params(random_state=random_state)\n # Define the parameter grid for hyperparameter tuning\n param_grid = {\"max_depth\": [None, 5, 10, 20], \"min_samples_leaf\": [1, 2, 4]}\n\n # Initialize GridSearchCV with the model and parameter grid\n grid_search = GridSearchCV(\n self._model, param_grid, cv=cv_folds, scoring=\"roc_auc\", verbose=1\n )\n\n # Perform the grid search on the provided data\n grid_search.fit(X, y)\n\n # Update the model with the best found parameters\n self._model = grid_search.best_estimator_\n\n # Store the best AUC score\n self._auc_score = grid_search.best_score_\n\n def get_relevant_variables(self, threshold: float) -> np.ndarray:\n \"\"\"\n Identifies features with importance greater than a specified threshold.\n\n Args:\n threshold (float): The threshold for determining feature relevance.\n\n Returns:\n np.ndarray: An array of indices of relevant features.\n \"\"\"\n\n significant_indices = np.where(self._model.feature_importances_ > threshold)[0]\n return significant_indices\n\n def predict(self, X: np.ndarray) -> np.ndarray:\n \"\"\"\n Predicts the target labels for the given data.\n\n Args:\n X (np.ndarray): The input features as a NumPy array.\n\n Returns:\n np.ndarray: The predicted target labels.\n \"\"\"\n return self._model.predict(X)" } ]

[ { "identifier": "get_nwp", "path": "quartz_solar_forecast/data.py", "snippet": "def get_nwp(site: PVSite, ts: datetime, nwp_source: str = \"icon\") -> xr.Dataset:\n \"\"\"\n Get GFS NWP data for a point time space and time\n\n :param site: the PV site\n :param ts: the timestamp for when you want the forecast for\n :param nwp_source: the nwp data source. Either \"gfs\" or \"icon\". Defaults to \"icon\"\n :return: nwp forecast in xarray\n \"\"\"\n\n variables = [\n \"visibility\",\n \"windspeed_10m\",\n \"temperature_2m\",\n \"precipitation\",\n \"shortwave_radiation\",\n \"direct_radiation\",\n \"cloudcover_low\",\n \"cloudcover_mid\",\n \"cloudcover_high\",\n ]\n\n start = ts.date()\n end = start + pd.Timedelta(days=7)\n\n # Getting NWP, from OPEN METEO\n url_nwp_source = None\n if nwp_source == \"icon\":\n url_nwp_source = \"dwd-icon\"\n elif nwp_source == \"gfs\":\n url_nwp_source = \"gfs\"\n else:\n raise Exception(f'Source ({nwp_source}) must be either \"icon\" or \"gfs\"')\n\n # Pull data from the nwp_source provided \n url = (\n f\"https://api.open-meteo.com/v1/{url_nwp_source}?\"\n f\"latitude={site.latitude}&longitude={site.longitude}\"\n f\"&hourly={','.join(variables)}\"\n f\"&start_date={start}&end_date={end}\"\n )\n r = requests.get(url)\n d = json.loads(r.text)\n\n # If the nwp_source is ICON, get visibility data from GFS as its not available for icon on Open Meteo\n if nwp_source == \"icon\":\n url = (\n f\"https://api.open-meteo.com/v1/gfs?\"\n f\"latitude={site.latitude}&longitude={site.longitude}\"\n f\"&hourly=visibility\"\n f\"&start_date={start}&end_date={end}\"\n )\n r_gfs = requests.get(url)\n d_gfs = json.loads(r_gfs.text)\n\n # extract visibility data from gfs reponse\n gfs_visibility_data = d_gfs[\"hourly\"][\"visibility\"]\n\n # add visibility to the icon reponse to make a complete json file \n d[\"hourly\"][\"visibility\"] = gfs_visibility_data\n\n # convert data into xarray\n df = pd.DataFrame(d[\"hourly\"])\n df[\"time\"] = pd.to_datetime(df[\"time\"])\n df = df.rename(\n columns={\n \"visibility\": \"vis\",\n \"windspeed_10m\": \"si10\",\n \"temperature_2m\": \"t\",\n \"precipitation\": \"prate\",\n \"shortwave_radiation\": \"dswrf\",\n \"direct_radiation\": \"dlwrf\",\n \"cloudcover_low\": \"lcc\",\n \"cloudcover_mid\": \"mcc\",\n \"cloudcover_high\": \"hcc\",\n }\n )\n df = df.set_index(\"time\")\n data_xr = format_nwp_data(df, nwp_source, site)\n\n return data_xr" }, { "identifier": "make_pv_data", "path": "quartz_solar_forecast/data.py", "snippet": "def make_pv_data(site: PVSite, ts: pd.Timestamp) -> xr.Dataset:\n \"\"\"\n Make fake PV data for the site\n\n Later we could add PV history here\n\n :param site: the PV site\n :param ts: the timestamp of the site\n :return: The fake PV dataset in xarray form\n \"\"\"\n\n # make fake pv data, this is where we could add history of a pv system\n generation_wh = [[np.nan]]\n lon = [site.longitude]\n lat = [site.latitude]\n timestamp = [ts]\n pv_id = [1]\n\n da = xr.DataArray(\n data=generation_wh,\n dims=[\"pv_id\", \"timestamp\"],\n coords=dict(\n longitude=([\"pv_id\"], lon),\n latitude=([\"pv_id\"], lat),\n timestamp=timestamp,\n pv_id=pv_id,\n kwp=([\"pv_id\"], [site.capacity_kwp]),\n tilt=([\"pv_id\"], [site.tilt]),\n orientation=([\"pv_id\"], [site.orientation]),\n ),\n )\n da = da.to_dataset(name=\"generation_wh\")\n\n return da" }, { "identifier": "PVSite", "path": "quartz_solar_forecast/pydantic_models.py", "snippet": "class PVSite(BaseModel):\n latitude: float = Field(..., description=\"the latitude of the site\", ge=-90, le=90)\n longitude: float = Field(..., description=\"the longitude of the site\", ge=-180, le=180)\n capacity_kwp: float = Field(..., description=\"the capacity [kwp] of the site\", ge=0)\n tilt: float = Field(\n default=35,\n description=\"the tilt of the site [degrees], the panels' angle relative to horizontal ground\",\n ge=0,\n le=90,\n )\n orientation: float = Field(\n default=180,\n description=\"the orientation of the site [degrees], the angle between north and the direction the panels face, measured on the horizontal plane.\",\n ge=0,\n le=360,\n )" }, { "identifier": "forecast_v1", "path": "quartz_solar_forecast/forecasts/v1.py", "snippet": "def forecast_v1(nwp_source:str, nwp_xr:xr.Dataset, pv_xr:xr.Dataset, ts:pd.Timestamp, model=None):\n \"\"\"\n Run the forecast\n\n This runs the pv-site-prediction model from the psp library.\n \"\"\"\n\n if model is None:\n model = load_model(f\"{dir_path}/../models/model-0.3.0.pkl\")\n\n # format pv and nwp data\n pv_data_source = NetcdfPvDataSource(\n pv_xr,\n id_dim_name=\"pv_id\",\n timestamp_dim_name=\"timestamp\",\n rename={\"generation_wh\": \"power\", \"kwp\": \"capacity\"},\n ignore_pv_ids=[],\n )\n # make NwpDataSource\n nwp = NwpDataSource(nwp_xr, value_name=nwp_source)\n model.set_data_sources(pv_data_source=pv_data_source, nwp_data_sources={nwp_source: nwp})\n\n # make prediction.\n # Note pv_id=1 is arbitrary, but the pv_xr must have this in it.\n x = X(pv_id=\"1\", ts=ts)\n pred = model.predict(x)\n\n # format into timerange and put into pd dataframe\n times = pd.date_range(start=x.ts, periods=len(pred.powers), freq=\"15min\")\n pred_df = pd.DataFrame({\"power_wh\": pred.powers}, index=times)\n\n return pred_df" }, { "identifier": "format_nwp_data", "path": "quartz_solar_forecast/data.py", "snippet": "def format_nwp_data(df: pd.DataFrame, nwp_source:str, site: PVSite):\n data_xr = xr.DataArray(\n data=df.values,\n dims=[\"step\", \"variable\"],\n coords=dict(\n step=(\"step\", df.index - df.index[0]),\n variable=df.columns,\n ),\n )\n data_xr = data_xr.to_dataset(name=nwp_source)\n data_xr = data_xr.assign_coords(\n {\"x\": [site.longitude], \"y\": [site.latitude], \"time\": [df.index[0]]}\n )\n return data_xr" } ]

[ { "identifier": "Turn", "path": "dispel/providers/generic/activity/turning.py", "snippet": "class Turn:\n \"\"\"Class to encapsulate turns and turn related gyroscope data.\n\n Parameters\n ----------\n start\n The start date time of the turn.\n end\n The end date time of the turn.\n data\n The angular velocity time series of the turn. The data set should\n ensure to be at least of the duration of time provided with\n ``start`` and ``end``. It should be in rad/s and sampling has to be\n at a constant frequency.\n\n Attributes\n ----------\n start\n The start date time of the turn.\n end\n The end date time of the turn.\n \"\"\"\n\n def __init__(self, start: datetime, end: datetime, data: pd.Series):\n self.start = start\n self.end = end\n self._data = data\n\n def expand(self, threshold: float) -> \"Turn\":\n \"\"\"Expand the ``start`` and ``end`` of the turn to the given threshold.\n\n This expands the turn until start and end are below the provided\n threshold of turn speed. The expansion relies on the data provided\n during the construction of the turn and should not be confused with\n what is available via :data:`data`, which is always limited to the\n boundaries specified with :data:`start` and :data:`end`.\n\n Parameters\n ----------\n threshold\n The threshold until which to expand the turn.\n\n Returns\n -------\n Turn\n A new turn with expanded start and end time stamps based on\n associated data.\n \"\"\"\n below = self._data * self.direction < threshold\n\n before = below[: self.start] # type: ignore\n after = below[self.end :] # type: ignore\n\n start, end = self.start, self.end\n freq = self._data.index.freq.delta\n\n # adjust start\n if not before[before].empty:\n start = before[before].index[-1] + freq\n elif not before.any():\n start = before.index[0]\n\n # adjust end\n if not after[after].empty:\n end = after[after].index[0] - freq\n elif not after.any():\n end = after.index[-1]\n\n return Turn(start, end, self._data)\n\n @property\n def data(self) -> pd.Series:\n \"\"\"Get the angular velocity data associated with the turn.\n\n Returns\n -------\n pandas.Series\n Angular velocity series between :data:`start` and :data:`end` of\n the turn.\n \"\"\"\n return self._data[self.start : self.end] # type: ignore\n\n @property\n def duration(self) -> float:\n \"\"\"Get the duration of the turn.\n\n Returns\n -------\n float\n The duration of the turn in seconds.\n \"\"\"\n return (self.end - self.start).total_seconds()\n\n @property\n def direction(self) -> int:\n \"\"\"Get the direction of the turn.\n\n Returns\n -------\n int\n The direction of the turn. If the turning direction is positive\n ``1`` is returned. Otherwise ``-1``.\n \"\"\"\n return 1 if self.angle > 0 else -1\n\n @property\n def angle(self) -> float:\n \"\"\"Get the angle of the turn.\n\n Returns\n -------\n float\n The angle of the turn in rad/s.\n \"\"\"\n delta = self._data.index.freq.delta.total_seconds()\n return self.data.sum() * delta\n\n def merge(self, other) -> \"Turn\":\n \"\"\"Merge this turn with another one.\n\n Parameters\n ----------\n other\n The other turn to merge this one with.\n\n Returns\n -------\n Turn\n The new merged turn. The new turn uses the earlier start and later\n end of both, respectively. The data will be based on this turn.\n \"\"\"\n return Turn(min(self.start, other.start), max(self.end, other.end), self._data)\n\n def __repr__(self):\n return (\n f\"<Turn: {self.start} - {self.end} ({self.duration} s, \"\n f\"{self.angle.round(3)} rad, {self.direction})>\"\n )" }, { "identifier": "el_gohary_detect_turns", "path": "dispel/providers/generic/activity/turning.py", "snippet": "def el_gohary_detect_turns(data: pd.Series) -> List[Turn]:\n \"\"\"Detect turns based on the El Gohary et al. algorithm [1]_ .\n\n This method performs the detection after aligning and filtering the\n gyroscope time series (see El Gohary et al. algorithm 1, row 4).\n\n Parameters\n ----------\n data\n A pandas series of angular velocity used to search for turns.\n\n Returns\n -------\n List[Turn]\n A list of detected turns.\n\n References\n ----------\n .. [1] El-Gohary, Mahmoud, et al. \"Continuous monitoring of turning in\n patients with movement disability.\" Sensors 14.1 (2014): 356-369.\n https://doi.org/10.3390/s140100356\n \"\"\"\n # detect peaks\n peak_index, _ = signal.find_peaks(data.abs(), EL_GOHARY_TH_MAX)\n peaks = pd.Series(data[peak_index], index=data.index[peak_index])\n\n # initialize turns with peaks found\n turns = [Turn(x, x, data) for x in peaks.index.tolist()]\n\n # expand turns\n expanded_turns = [t.expand(EL_GOHARY_TH_MIN) for t in turns]\n\n # merge turns\n merged_turns = merge_turns(expanded_turns, EL_GOHARY_TH_MERGE)\n\n # filter turns\n filtered_turns = []\n for turn in merged_turns:\n if TH_MIN_TURN_DURATION < turn.duration < TH_MAX_TURN_DURATION and abs(\n turn.angle\n ) >= np.radians(TH_MIN_TURN_ANGLE_DEGREE):\n filtered_turns.append(turn)\n\n return filtered_turns" } ]

[ { "identifier": "decrypt_aes128cbc_buffer_to_str", "path": "custom_components/mazda/pymazda/crypto_utils.py", "snippet": "def decrypt_aes128cbc_buffer_to_str(data, key, iv): # noqa: D103\n cipher = Cipher(algorithms.AES(key.encode(\"ascii\")), modes.CBC(iv.encode(\"ascii\")))\n decryptor = cipher.decryptor()\n decrypted = decryptor.update(data) + decryptor.finalize()\n unpadder = padding.PKCS7(128).unpadder()\n return unpadder.update(decrypted) + unpadder.finalize()" }, { "identifier": "encrypt_aes128cbc_buffer_to_base64_str", "path": "custom_components/mazda/pymazda/crypto_utils.py", "snippet": "def encrypt_aes128cbc_buffer_to_base64_str(data, key, iv): # noqa: D103\n padder = padding.PKCS7(128).padder()\n padded_data = padder.update(data) + padder.finalize()\n cipher = Cipher(algorithms.AES(key.encode(\"ascii\")), modes.CBC(iv.encode(\"ascii\")))\n encryptor = cipher.encryptor()\n encrypted = encryptor.update(padded_data) + encryptor.finalize()\n return base64.b64encode(encrypted).decode(\"utf-8\")" }, { "identifier": "encrypt_rsaecbpkcs1_padding", "path": "custom_components/mazda/pymazda/crypto_utils.py", "snippet": "def encrypt_rsaecbpkcs1_padding(data, public_key): # noqa: D103\n public_key = serialization.load_der_public_key(base64.b64decode(public_key))\n return public_key.encrypt(data.encode(\"utf-8\"), asymmetric_padding.PKCS1v15())" }, { "identifier": "generate_usher_device_id_from_seed", "path": "custom_components/mazda/pymazda/crypto_utils.py", "snippet": "def generate_usher_device_id_from_seed(seed): # noqa: D103\n hash = hashlib.sha256(seed.encode()).hexdigest().upper()\n id = int(hash[0:8], 16)\n return \"ACCT\" + str(id)" }, { "identifier": "generate_uuid_from_seed", "path": "custom_components/mazda/pymazda/crypto_utils.py", "snippet": "def generate_uuid_from_seed(seed): # noqa: D103\n hash = hashlib.sha256(seed.encode()).hexdigest().upper()\n return (\n hash[0:8]\n + \"-\"\n + hash[8:12]\n + \"-\"\n + hash[12:16]\n + \"-\"\n + hash[16:20]\n + \"-\"\n + hash[20:32]\n )" }, { "identifier": "MazdaAccountLockedException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaAccountLockedException(Exception):\n \"\"\"Raised when account is locked from too many login attempts.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaAPIEncryptionException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaAPIEncryptionException(Exception):\n \"\"\"Raised when server reports that the request is not encrypted properly.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaAuthenticationException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaAuthenticationException(Exception):\n \"\"\"Raised when email address or password are invalid during authentication.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaConfigException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaConfigException(Exception): # noqa: D100\n \"\"\"Raised when Mazda API client is configured incorrectly.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaException(Exception):\n \"\"\"Raised when an unknown error occurs during API interaction.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaLoginFailedException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaLoginFailedException(Exception):\n \"\"\"Raised when login fails for an unknown reason.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaRequestInProgressException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaRequestInProgressException(Exception):\n \"\"\"Raised when a request fails because another request is already in progress.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "MazdaTokenExpiredException", "path": "custom_components/mazda/pymazda/exceptions.py", "snippet": "class MazdaTokenExpiredException(Exception):\n \"\"\"Raised when server reports that the access token has expired.\"\"\"\n\n def __init__(self, status):\n \"\"\"Initialize exception.\"\"\"\n super().__init__(status)\n self.status = status" }, { "identifier": "SensorDataBuilder", "path": "custom_components/mazda/pymazda/sensordata/sensor_data_builder.py", "snippet": "class SensorDataBuilder: # noqa: D101\n def __init__(self): # noqa: D107\n self.sensor_collection_start_timestamp = datetime.datetime.now(datetime.UTC)\n self.device_info_time = random.randrange(3, 8) * 1000\n\n self.system_info = SystemInfo()\n self.system_info.randomize()\n\n self.touch_event_list = TouchEventList()\n self.key_event_list = KeyEventList()\n self.background_event_list = BackgroundEventList()\n\n self.performance_test_results = PerformanceTestResults()\n self.performance_test_results.randomize()\n\n self.sensor_data_encryptor = SensorDataEncryptor()\n\n def generate_sensor_data(self): # noqa: D102\n self.touch_event_list.randomize(self.sensor_collection_start_timestamp)\n self.key_event_list.randomize(self.sensor_collection_start_timestamp)\n self.background_event_list.randomize(self.sensor_collection_start_timestamp)\n\n random_number = random.randrange(-(2**31), 2**31)\n\n orientation_event = self.generate_orientation_data_aa()\n orientation_event_count = orientation_event.count(\";\")\n motion_event = self.generate_motion_data_aa()\n motion_event_count = motion_event.count(\";\")\n\n sensor_data = \"\"\n sensor_data += SDK_VERSION\n sensor_data += \"-1,2,-94,-100,\"\n sensor_data += self.system_info.to_string()\n sensor_data += \",\"\n sensor_data += str(self.system_info.get_char_code_sum())\n sensor_data += \",\"\n sensor_data += str(random_number)\n sensor_data += \",\"\n sensor_data += str(\n int(timestamp_to_millis(self.sensor_collection_start_timestamp) / 2)\n )\n sensor_data += \"-1,2,-94,-101,\"\n sensor_data += \"do_en\"\n sensor_data += \",\"\n sensor_data += \"dm_en\"\n sensor_data += \",\"\n sensor_data += \"t_en\"\n sensor_data += \"-1,2,-94,-102,\"\n sensor_data += self.generate_edited_text()\n sensor_data += \"-1,2,-94,-108,\"\n sensor_data += self.key_event_list.to_string()\n sensor_data += \"-1,2,-94,-117,\"\n sensor_data += self.touch_event_list.to_string()\n sensor_data += \"-1,2,-94,-111,\"\n sensor_data += orientation_event\n sensor_data += \"-1,2,-94,-109,\"\n sensor_data += motion_event\n sensor_data += \"-1,2,-94,-144,\"\n sensor_data += self.generate_orientation_data_ac()\n sensor_data += \"-1,2,-94,-142,\"\n sensor_data += self.generate_orientation_data_ab()\n sensor_data += \"-1,2,-94,-145,\"\n sensor_data += self.generate_motion_data_ac()\n sensor_data += \"-1,2,-94,-143,\"\n sensor_data += self.generate_motion_event()\n sensor_data += \"-1,2,-94,-115,\"\n sensor_data += self.generate_misc_stat(\n orientation_event_count, motion_event_count\n )\n sensor_data += \"-1,2,-94,-106,\"\n sensor_data += self.generate_stored_values_f()\n sensor_data += \",\"\n sensor_data += self.generate_stored_values_g()\n sensor_data += \"-1,2,-94,-120,\"\n sensor_data += self.generate_stored_stack_traces()\n sensor_data += \"-1,2,-94,-112,\"\n sensor_data += self.performance_test_results.to_string()\n sensor_data += \"-1,2,-94,-103,\"\n sensor_data += self.background_event_list.to_string()\n\n encrypted_sensor_data = self.sensor_data_encryptor.encrypt_sensor_data(\n sensor_data\n )\n return encrypted_sensor_data\n\n def generate_edited_text(self): # noqa: D102\n return \"\"\n\n def generate_orientation_data_aa(self): # noqa: D102\n return \"\"\n\n def generate_motion_data_aa(self): # noqa: D102\n return \"\"\n\n def generate_orientation_data_ac(self): # noqa: D102\n return \"\"\n\n def generate_orientation_data_ab(self): # noqa: D102\n return \"\"\n\n def generate_motion_data_ac(self): # noqa: D102\n return \"\"\n\n def generate_motion_event(self): # noqa: D102\n return \"\"\n\n def generate_misc_stat( # noqa: D102\n self, orientation_data_count, motion_data_count\n ): # noqa: D102\n sum_of_text_event_values = self.key_event_list.get_sum()\n sum_of_touch_event_timestamps_and_types = self.touch_event_list.get_sum()\n orientation_data_b = 0\n motion_data_b = 0\n overall_sum = (\n sum_of_text_event_values\n + sum_of_touch_event_timestamps_and_types\n + orientation_data_b\n + motion_data_b\n )\n\n now_timestamp = datetime.datetime.now(datetime.UTC)\n time_since_sensor_collection_start = int(\n (now_timestamp - self.sensor_collection_start_timestamp)\n / datetime.timedelta(milliseconds=1)\n )\n\n return \",\".join(\n [\n str(sum_of_text_event_values),\n str(sum_of_touch_event_timestamps_and_types),\n str(orientation_data_b),\n str(motion_data_b),\n str(overall_sum),\n str(time_since_sensor_collection_start),\n str(len(self.key_event_list.key_events)),\n str(len(self.touch_event_list.touch_events)),\n str(orientation_data_count),\n str(motion_data_count),\n str(self.device_info_time),\n str(random.randrange(5, 15) * 1000),\n \"0\",\n str(\n feistel_cipher(\n overall_sum,\n len(self.key_event_list.key_events)\n + len(self.touch_event_list.touch_events)\n + orientation_data_count\n + motion_data_count,\n time_since_sensor_collection_start,\n )\n ),\n str(timestamp_to_millis(self.sensor_collection_start_timestamp)),\n \"0\",\n ]\n )\n\n def generate_stored_values_f(self): # noqa: D102\n return \"-1\"\n\n def generate_stored_values_g(self): # noqa: D102\n return \"0\"\n\n def generate_stored_stack_traces(self): # noqa: D102\n return \"\"" } ]

[ { "identifier": "UpCunet2x", "path": "src/cugan/cugan_arch.py", "snippet": "class UpCunet2x(nn.Module): # 完美tile，全程无损\n def __init__(self, in_channels=3, out_channels=3):\n super(UpCunet2x, self).__init__()\n self.unet1 = UNet1(in_channels, out_channels, deconv=True)\n self.unet2 = UNet2(in_channels, out_channels, deconv=False)\n\n def forward(self, x): # 1.7G\n n, c, h0, w0 = x.shape\n # if(tile_mode==0):#不tile\n\n ph = ((h0 - 1) // 2 + 1) * 2\n pw = ((w0 - 1) // 2 + 1) * 2\n x = F.pad(x, (18, 18 + pw - w0, 18, 18 + ph - h0), \"reflect\") # 需要保证被2整除\n x = self.unet1.forward(x)\n x0 = self.unet2.forward(x)\n x1 = F.pad(x, (-20, -20, -20, -20))\n x = torch.add(x0, x1)\n if w0 != pw or h0 != ph:\n x = x[:, :, : h0 * 2, : w0 * 2]\n return x" }, { "identifier": "UpCunet3x", "path": "src/cugan/cugan_arch.py", "snippet": "class UpCunet3x(nn.Module): # 完美tile，全程无损\n def __init__(self, in_channels=3, out_channels=3):\n super(UpCunet3x, self).__init__()\n self.unet1 = UNet1x3(in_channels, out_channels, deconv=True)\n self.unet2 = UNet2(in_channels, out_channels, deconv=False)\n\n def forward(self, x): # 1.7G\n n, c, h0, w0 = x.shape\n # if(tile_mode==0):#不tile\n\n ph = ((h0 - 1) // 4 + 1) * 4\n pw = ((w0 - 1) // 4 + 1) * 4\n x = F.pad(x, (14, 14 + pw - w0, 14, 14 + ph - h0), \"reflect\") # 需要保证被2整除\n x = self.unet1.forward(x)\n x0 = self.unet2.forward(x)\n x1 = F.pad(x, (-20, -20, -20, -20))\n x = torch.add(x0, x1)\n if w0 != pw or h0 != ph:\n x = x[:, :, : h0 * 3, : w0 * 3]\n return x" }, { "identifier": "UpCunet4x", "path": "src/cugan/cugan_arch.py", "snippet": "class UpCunet4x(nn.Module): # 完美tile，全程无损\n def __init__(self, in_channels=3, out_channels=3):\n super(UpCunet4x, self).__init__()\n self.unet1 = UNet1(in_channels, 64, deconv=True)\n self.unet2 = UNet2(64, 64, deconv=False)\n self.ps = nn.PixelShuffle(2)\n self.conv_final = nn.Conv2d(64, 12, 3, 1, padding=0, bias=True)\n\n def forward(self, x):\n n, c, h0, w0 = x.shape\n x00 = x\n # if(tile_mode==0):#不tile\n\n ph = ((h0 - 1) // 2 + 1) * 2\n pw = ((w0 - 1) // 2 + 1) * 2\n x = F.pad(x, (19, 19 + pw - w0, 19, 19 + ph - h0), \"reflect\") # 需要保证被2整除\n x = self.unet1.forward(x)\n x0 = self.unet2.forward(x)\n x1 = F.pad(x, (-20, -20, -20, -20))\n x = torch.add(x0, x1)\n x = self.conv_final(x)\n x = F.pad(x, (-1, -1, -1, -1))\n x = self.ps(x)\n if w0 != pw or h0 != ph:\n x = x[:, :, : h0 * 4, : w0 * 4]\n x += F.interpolate(x00, scale_factor=4, mode=\"nearest\")\n return x" }, { "identifier": "UpCunet2x_fast", "path": "src/cugan/cugan_arch.py", "snippet": "class UpCunet2x_fast(nn.Module): # 完美tile，全程无损\n def __init__(self, in_channels=3, out_channels=3):\n super(UpCunet2x_fast, self).__init__()\n self.unet1 = UNet1(12, 64, deconv=True)\n self.unet2 = UNet2(64, 64, deconv=False)\n self.ps = nn.PixelShuffle(2)\n self.conv_final = nn.Conv2d(64, 12, 3, 1, padding=0, bias=True)\n self.inv = pixel_unshuffle(2)\n\n def forward(self, x):\n n, c, h0, w0 = x.shape\n x00 = x\n # if(tile_mode==0):#不tile\n\n ph = ((h0 - 1) // 2 + 1) * 2\n pw = ((w0 - 1) // 2 + 1) * 2\n x = F.pad(x, (38, 38 + pw - w0, 38, 38 + ph - h0), \"reflect\") # 需要保证被2整除\n x = self.inv(x) # +18\n x = self.unet1.forward(x)\n x0 = self.unet2.forward(x)\n x1 = F.pad(x, (-20, -20, -20, -20))\n x = torch.add(x0, x1)\n x = self.conv_final(x)\n # with open(r\"C:\\Users\\liujing\\Desktop\\log.txt\",\"a+\")as f:\n # f.write(\"%s\"%(str(x.shape)))\n # f.flush()\n x = F.pad(x, (-1, -1, -1, -1))\n x = self.ps(x)\n if w0 != pw or h0 != ph:\n x = x[:, :, : h0 * 2, : w0 * 2]\n x += F.interpolate(x00, scale_factor=2, mode=\"nearest\")\n return x" } ]

[ { "identifier": "FirefoxBot", "path": "fastbots/firefox_bot.py", "snippet": "class FirefoxBot(Bot):\n \"\"\"\n Firefox Bot\n\n Class representing the Firefox Bot implementation.\n\n Attributes:\n _driver (WebDriver): The WebDriver instance for Firefox.\n _wait (WebDriverWait): The WebDriverWait instance for Firefox.\n\n Methods:\n __init__(): Initializes all attributes of the Firefox Bot instance.\n save_screenshot(): Saves the browser's screenshot to a PNG file.\n __load_preferences__(): Loads Firefox preferences from a JSON file.\n __load_options__(): Loads Firefox options, including user agent and download directory.\n __load_driver__(): Loads and configures options for the Firefox driver.\n\n Example:\n ```python\n with FirefoxBot() as bot:\n bot.save_screenshot()\n ```\n \"\"\"\n\n def __init__(self) -> None:\n \"\"\"\n Initializes all attributes of the Firefox Bot instance.\n \"\"\"\n super().__init__()\n\n # Load the configured driver\n self._driver: WebDriver = self.__load_driver__()\n\n # Default wait\n self._wait: WebDriverWait = WebDriverWait(driver=self._driver, timeout=config.SELENIUM_DEFAULT_WAIT, poll_frequency=1)\n\n def save_screenshot(self) -> str:\n \"\"\"\n Saves the browser's screenshot to a PNG file.\n\n The file path can be specified in the settings.\n \"\"\"\n if not Path(config.BOT_SCREENSHOT_DOWNLOAD_FOLDER_PATH).exists():\n Path(config.BOT_SCREENSHOT_DOWNLOAD_FOLDER_PATH).mkdir(exist_ok=True, parents=True)\n\n file_path: Path = Path(config.BOT_SCREENSHOT_DOWNLOAD_FOLDER_PATH) / f'{datetime.now().strftime(\"%Y-%m-%d_%H-%M-%S\")}.png'\n self._driver.get_full_page_screenshot_as_file(str(file_path.absolute()))\n return str(file_path.absolute())\n\n def __load_preferences__(self) -> FirefoxProfile:\n \"\"\"\n Load Firefox Preferences\n\n Load all the preferences for Firefox stored in a JSON file, specified in the config.\n\n Returns:\n FirefoxProfile: The Firefox profile with loaded preferences.\n \"\"\"\n # Initialize an empty profile for the settings\n firefox_profile: FirefoxProfile = FirefoxProfile()\n\n if Path(config.BOT_PREFERENCES_FILE_PATH).exists():\n # Load all the preferences from the file\n with open(config.BOT_PREFERENCES_FILE_PATH, 'r') as file:\n data = json.load(file)\n\n # Iterate through all the data in the file\n for key, value in data.items():\n firefox_profile.set_preference(key, value)\n\n return firefox_profile\n\n def __load_options__(self) -> FirefoxOptions:\n \"\"\"\n Load Firefox Options\n\n Load all the default Firefox options.\n\n Returns:\n FirefoxOptions: The configured Firefox options.\n \"\"\"\n # Firefox configurations\n firefox_options: FirefoxOptions = FirefoxOptions()\n \n # Add all the arguments specified in the config\n if config.BOT_ARGUMENTS != 'None':\n arguments = config.BOT_ARGUMENTS.replace(' ', '').strip().split(',')\n for argument in arguments:\n firefox_options.add_argument(argument)\n\n firefox_profile: FirefoxProfile = self.__load_preferences__()\n\n # Basic static settings: download directory as temp and user agent from config\n firefox_profile.set_preference('general.useragent.override', config.BOT_USER_AGENT)\n firefox_profile.set_preference('browser.download.folderList', 2)\n firefox_profile.set_preference('browser.download.dir', self._temp_dir)\n\n # Add the profile to the Firefox options\n firefox_options.profile = firefox_profile\n\n return firefox_options\n \n def __load_driver__(self) -> WebDriver:\n \"\"\"\n Load Firefox Driver\n\n Load and configure all the options for the Firefox driver.\n\n Returns:\n WebDriver: The configured WebDriver instance for Firefox.\n \"\"\"\n seleniumwire_options = {\n 'disable_capture': config.SELENIUM_DISABLE_CAPTURE,\n 'enable_har': config.SELENIUM_ENABLE_HAR_CAPTURE\n }\n\n if config.BOT_PROXY_ENABLED:\n # Proxy settings\n seleniumwire_options['proxy'] = {\n 'http': config.BOT_HTTP_PROXY,\n 'https': config.BOT_HTTPS_PROXY,\n }\n \n # Initialize Firefox with options\n return Firefox(\n options=self.__load_options__(),\n seleniumwire_options=seleniumwire_options\n )" }, { "identifier": "config", "path": "fastbots/config.py", "snippet": "class DriverType(Enum):\n FIREFOX = 1\n CHROME = 2\nENV_DEVELOPMENT: str = 'development'\nENV_RELEASE: str = 'release'\nLOG_LEVEL: int = config('LOGLEVEL', default=logging.DEBUG, cast=int)\nENV: str = config('ENV', default=ENV_DEVELOPMENT, cast=str)\nPROJECT_NAME: str = config('PROJECT_NAME', default='fastbot', cast=str)\nAPP_VERSION: str = config('APP_VERSION', default='0.2.6', cast=str)\nBOT_DRIVER_TYPE: DriverType = config('BOT_DRIVER_TYPE', default='firefox', cast=DriverType.from_str)\nBOT_DOWNLOAD_FOLDER_PATH: str = config('BOT_DOWNLOAD_FOLDER_PATH', default=None, cast=str)\nBOT_STRICT_DOWNLOAD_WAIT: bool = config('BOT_STRICT_DOWNLOAD_WAIT', default=True, cast=bool)\nBOT_ARGUMENTS: str = config('BOT_ARGUMENTS', default=None, cast=str)\nBOT_USER_AGENT: str = config('BOT_USER_AGENT', default=f'{PROJECT_NAME} {APP_VERSION}', cast=str)\nBOT_PROXY_ENABLED: bool = config('BOT_PROXY_ENABLED', default=False, cast=bool)\nBOT_HTTP_PROXY: str = config('BOT_HTTP_PROXY', default=None, cast=str)\nBOT_HTTPS_PROXY: str = config('BOT_HTTPS_PROXY', default=BOT_HTTP_PROXY, cast=str)\nBOT_SCREENSHOT_DOWNLOAD_FOLDER_PATH: str = config('BOT_SCREENSHOT_DOWNLOAD_FOLDER_PATH', default='debug/', cast=str)\nBOT_HTML_DOWNLOAD_FOLDER_PATH: str = config('BOT_HTML_DOWNLOAD_FOLDER_PATH', default='debug/', cast=str)\nBOT_COOKIES_FILE_PATH: str = config('BOT_COOKIES_FILE_PATH', default='cookies.pkl', cast=str)\nBOT_PREFERENCES_FILE_PATH: str = config('BOT_PREFERENCES_FILE_PATH', default='preferences.json', cast=str)\nBOT_MAX_RETRIES: int = config('BOT_MAX_RETRIES', default=2, cast=int)\nBOT_RETRY_DELAY: int = config('BOT_RETRY_DELAY', default=10, cast=int)\nSELENIUM_GLOBAL_IMPLICIT_WAIT: int = config('SELENIUM_GLOBAL_IMPLICIT_WAIT', default=5, cast=int)\nSELENIUM_EXPECTED_URL_CHECK: bool = config('SELENIUM_EXPECTED_URL_CHECK', default=True, cast=bool)\nSELENIUM_EXPECTED_URL_TIMEOUT: int = config('SELENIUM_EXPECTED_URL_TIMEOUT', default=5, cast=int)\nSELENIUM_DEFAULT_WAIT: int = config('SELENIUM_DEFAULT_WAIT', default=5, cast=int)\nSELENIUM_FILE_DOWNLOAD_TIMEOUT: int = config('SELENIUM_FILE_DOWNLOAD_TIMEOUT', default=20, cast=int)\nSELENIUM_LOCATORS_FILE: str = config('SELENIUM_LOCATORS_FILE', default='locators.ini', cast=str)\nSELENIUM_DISABLE_CAPTURE: bool = config('SELENIUM_DISABLE_CAPTURE', default=True, cast=bool)\nSELENIUM_IN_SCOPE_CAPTURE: str = config('SELENIUM_IN_SCOPE_CAPTURE', default=None, cast=str)\nSELENIUM_ENABLE_HAR_CAPTURE: bool = config('SELENIUM_ENABLE_HAR_CAPTURE', default=False, cast=bool)\nCAPSOLVER_API_KEY: str = config('CAPSOLVER_API_KEY', default=None, cast=str)\n def from_str(label):" }, { "identifier": "Payload", "path": "fastbots/payload.py", "snippet": "class Payload:\n \"\"\"\n Payload class for managing input data, downloads, and output data.\n \"\"\"\n\n input_data: Dict[str, str] = field(default_factory=dict)\n downloads: List[str] = field(default_factory=list)\n output_data: Dict[str, str] = field(default_factory=dict)" } ]

[ { "identifier": "generate_response", "path": "common/agentenv/rlhf_env.py", "snippet": "def generate_response(\n model: torch.nn.Module, \n *, \n input_ids: torch.tensor, \n max_length:int, \n eos_token_id: int\n):\n \"\"\"Generate a response using the model.\"\"\"\n generated_sequence = []\n probs_list = []\n model_in = torch.clone(input_ids)\n with torch.no_grad():\n for i in range(max_length):\n # Get the logits using the forward() method\n logits = model(model_in).logits\n\n # Get the logits of the last token\n next_token_logits = logits[:, -1, :]\n\n # Apply a softmax function to the logits to get the probabilities\n probs = next_token_logits.softmax(dim=-1)\n\n # if not probs_list:\n # prev_probs = logits[:, :-1, :].softmax(dim=-1)\n # probs_list.extend(prev_probs.unbind(1))\n\n # Sample the next token from the probability distribution\n next_token = torch.multinomial(probs, num_samples=1)\n\n # Append the probabilities and the generated token\n generated_sequence.append(next_token)\n # probs_list.append(probs)\n\n # Update the input_ids with the generated token\n model_in = torch.cat([model_in, next_token], dim=-1)\n\n if next_token.item() == eos_token_id:\n break\n\n # Decode and print the generated sequence\n generated_tokens = torch.cat(generated_sequence, dim=-1)\n\n # Stack the probabilities tensor --> this resulted in N - 1 probs missing the last one, to get that we have to do another forward pass, so we may as well do one round in the end to compute all the probs.\n # probs_tensor = torch.concat(probs_list, dim=0)\n\n logit_tensor = model(model_in).logits\n\n return {\n \"sequence\": torch.cat([input_ids, generated_tokens], dim=-1),\n \"logits\": logit_tensor,\n \"n_input_tokens\": input_ids.shape[-1],\n \"n_generated_tokens\": generated_tokens.shape[-1],\n }" }, { "identifier": "Buffer", "path": "rlhf/rl_algo/ppo/rlhf_buffer.py", "snippet": "class Buffer:\n \"\"\"This buffer should work for both torch and numpy types in the buffer items.\n \n Its job is to collect simple BufferItems but then upon calling \n convert_to_sample_batch, figure out the padding required to create blocks for \n tensors inside a SampleBatch.\n \"\"\"\n \n def __init__(self):\n self._buffer = []\n self._framework = None\n\n def append(self, item: BufferItem):\n if self._framework is None:\n self._framework = torch if isinstance(item.obs[\"input_ids\"], torch.Tensor) else np\n else:\n if self._framework == torch:\n assert isinstance(item.obs[\"input_ids\"], torch.Tensor), \"The buffer items should be of the same framework.\"\n else:\n assert isinstance(item.obs[\"input_ids\"], np.ndarray), \"The buffer items should be of the same framework.\"\n\n\n # under the same key, the values should be of the same length\n for k in (SampleBatch.ACTIONS, SampleBatch.OBS):\n flattened = tree.flatten(getattr(item, k))\n for i in range(len(flattened) - 1):\n if not flattened[i].shape[0] == flattened[i+1].shape[0]:\n raise ValueError(\"The values under the same key should be of the same length.\")\n \n self._buffer.append(item)\n \n def convert_to_sample_batch(self, padding_type: str = \"right\") -> SampleBatch:\n assert padding_type in (\"left\", \"right\"), \"The padding should be either 'left' or 'right'.\"\n keys = BufferItem.__dataclass_fields__.keys()\n\n sample_batch_dict = {}\n for key in keys:\n values = []\n for item in self._buffer: \n val = getattr(item, key)\n\n if isinstance(val, float):\n val = torch.tensor(val) if self._framework == torch else np.array(val)\n elif isinstance(val, dict):\n val = NestedDict(val)\n \n values.append(val)\n\n # some values may not have the same sequence length, so we need to pad them\n if key in (SampleBatch.ACTIONS, SampleBatch.OBS):\n # we should first obtain the max length for each value. Remember that each value is possibly a nested dict where the values are tensors.\n\n # TODO (Kourosh): This is not optimal since we are flattening the whole \n # tree structure, while all we need is the DFS traversal of the tree \n # and obtaining the first leave.\n\n # Each v is a nested dict where the leave values can be iterated easily\n max_length = max(next(iter(v.values())).shape[0] for v in values)\n \n for item in values:\n for nested_key, val in item.items():\n if val.shape[0] < max_length:\n padding = self._framework.zeros(\n (max_length - val.shape[0], *val.shape[1:]), \n dtype=val.dtype\n )\n\n if padding_type == \"left\":\n if self._framework == torch:\n item[nested_key] = torch.cat((padding, val), 0)\n else:\n item[nested_key] = np.concatenate((padding, val), 0)\n else:\n if self._framework == torch:\n item[nested_key] = torch.cat((val, padding), 0)\n else:\n item[nested_key] = np.concatenate((val, padding), 0)\n \n values = tree.map_structure(lambda *x: self._framework.stack(x,0), *values)\n sample_batch_dict[key] = values.asdict() if isinstance(values, NestedDict) else values\n\n return SampleBatch(sample_batch_dict)" }, { "identifier": "BufferItem", "path": "rlhf/rl_algo/ppo/rlhf_buffer.py", "snippet": "class BufferItem:\n # TODO (Kourosh): These names have to match those in the SampleBatch and \n # PostProcessing.\n obs: dict # keys (shape): input_ids (T,), attention_mask (T,)\n actions: dict # keys: sequence (T,), response_mask (T,), logits (T, VS), attention_mask (T, )\n infos: dict \n rewards: float # scalar (python float)\n value_targets: float # scalar (python float)\n advantages: float # scalar (python float)" } ]

[ { "identifier": "DataLoader", "path": "PRE/data.py", "snippet": "class DataLoader:\n '''\n The loader to load for evaluated task, with given prompt template to generate a series of prompts feeding for each LLM\n '''\n def __init__(self, args):\n self.path_data = args['path_data'] # the load path for the data\n self.format = args['format'] # the data format, csv (need a title line) or json (each line is a single data item)\n self.path_prompt = args['path_prompt'] if 'path_prompt' in args else None # the path of prompt template. In the prompt template, using {{key}} for the replacement of the key. For example, in the prompt \"You need answer a question: {{question}}\", the \"question\" field need to be included in the data\n if not os.path.exists(self.path_data):\n raise FileExistsError(\"Load task data failed: file not exist!\")\n assert self.format in ['csv', 'json']\n \n \n def generate_reader(self):\n if self.format == 'csv':\n with open(self.path_data, encoding='utf-8') as f:\n gen = csv.DictReader(f, skipinitialspace=True)\n elif self.format == 'json':\n gen = open(self.path_data, encoding='utf-8')\n else:\n raise Exception(\"Invalid data format\")\n return gen\n \n def get_prompt(self):\n if self.path_prompt is None:\n raise Exception(\"Exception: missing argument path_prompt\")\n if not os.path.exists(self.path_prompt):\n raise FileExistsError(\"Load task prompt template failed: file not exist!\")\n self.template_prompt = open(self.path_prompt, encoding='utf-8').read().strip()\n \n gen = self.generate_reader()\n \n for row in gen:\n if self.format == 'json':\n item = json.loads(row.strip())\n else:\n item = row\n \n prompt = self.template_prompt\n for key in item:\n prompt = prompt.replace(\"{{\" + key + \"}}\", item[key])\n yield prompt # a generator to return each prompt\n \n def get_task_items(self):\n data_list = []\n gen = self.generate_reader()\n for row in gen:\n if self.format == 'json':\n item = json.loads(row.strip())\n elif self.format == 'csv':\n item = dict(row)\n data_list.append(item)\n return data_list" }, { "identifier": "Auto_API", "path": "PRE/api.py", "snippet": "class Auto_API:\n @staticmethod\n def instantiate_api(api_type, args) -> LLM_API:\n for at, _API in API_type2class_list:\n if api_type == at:\n return _API(args)\n raise Exception(f\"Invalid api_type: {api_type}\")" }, { "identifier": "parse_response", "path": "PRE/utils.py", "snippet": "def parse_response(response, parse_type, nominal_list=None, nominal_ticks=None):\n '''\n parse_type: int, float or str\n if parse_type = str, then required parameter nominal_list and nominal_ticks\n nominal_list: a series of nominal types, its name\n nomianl_ticks: the corresponding nominal number (int)\n '''\n assert parse_type in ['int', 'float', 'str']\n if parse_type == 'int':\n nums = re.findall(r\"-?\\d+\", response)\n if len(nums) == 0:\n return None\n return int(nums[0])\n elif parse_type == 'float':\n nums = re.findall(r\"-?\\d+\\.?\\d*\", response)\n if len(nums) == 0:\n return None\n return int(nums[0])\n elif parse_type == 'str':\n appear_pos, cur_idx = math.inf, -1\n response = response.lower()\n for idx, label in enumerate(nominal_list):\n pos = response.find(label.lower())\n if pos != -1: # really appear!\n if pos < appear_pos:\n appear_pos, cur_idx = pos, idx\n if cur_idx == -1:\n return None\n else:\n return nominal_ticks[cur_idx]" } ]

[ { "identifier": "Thread", "path": "src/thread/thread.py", "snippet": "class Thread(threading.Thread, Generic[_Target_P, _Target_T]):\n \"\"\"\n Wraps python's `threading.Thread` class\n ---------------------------------------\n\n Type-Safe and provides more functionality on top\n \"\"\"\n\n status : ThreadStatus\n hooks : List[HookFunction]\n _returned_value: Data_Out\n\n errors : List[Exception]\n ignore_errors : Sequence[type[Exception]]\n suppress_errors: bool\n\n # threading.Thread stuff\n _initialized : bool\n _run : Callable\n\n\n def __init__(\n self,\n target: TargetFunction[_Target_P, _Target_T],\n args: Sequence[Data_In] = (),\n kwargs: Mapping[str, Data_In] = {},\n ignore_errors: Sequence[type[Exception]] = (),\n suppress_errors: bool = False,\n\n name: Optional[str] = None,\n daemon: bool = False,\n group = None,\n *overflow_args: Overflow_In,\n **overflow_kwargs: Overflow_In\n ) -> None:\n \"\"\"\n Initializes a thread\n\n Parameters\n ----------\n :param target: This should be a function that takes in anything and returns anything\n :param args: This should be an interable sequence of arguments parsed to the `target` function (e.g. tuple('foo', 'bar'))\n :param kwargs: This should be the kwargs pased to the `target` function (e.g. dict(foo = 'bar'))\n :param ignore_errors: This should be an interable sequence of all exceptions to ignore. To ignore all exceptions, parse tuple(Exception)\n :param suppress_errors: This should be a boolean indicating whether exceptions will be raised, else will only write to internal `errors` property\n :param name: This is an argument parsed to `threading.Thread`\n :param daemon: This is an argument parsed to `threading.Thread`\n :param group: This does nothing right now, but should be left as None\n :param *: These are arguments parsed to `threading.Thread`\n :param **: These are arguments parsed to `thread.Thread`\n \"\"\"\n _target = self._wrap_target(target)\n self._returned_value = None\n self.status = 'Idle'\n self.hooks = []\n\n self.errors = []\n self.ignore_errors = ignore_errors\n self.suppress_errors = suppress_errors\n\n super().__init__(\n target = _target,\n args = args,\n kwargs = kwargs,\n name = name,\n daemon = daemon,\n group = group,\n *overflow_args,\n **overflow_kwargs\n )\n\n\n def _wrap_target(self, target: TargetFunction[_Target_P, _Target_T]) -> TargetFunction[_Target_P, Union[_Target_T, None]]:\n \"\"\"Wraps the target function\"\"\"\n @wraps(target)\n def wrapper(*args: _Target_P.args, **kwargs: _Target_P.kwargs) -> Union[_Target_T, None]:\n self.status = 'Running'\n\n global Threads\n Threads.add(self)\n\n try:\n self._returned_value = target(*args, **kwargs)\n except Exception as e:\n if not any(isinstance(e, ignore) for ignore in self.ignore_errors):\n self.status = 'Errored'\n self.errors.append(e)\n return\n \n self.status = 'Invoking hooks'\n self._invoke_hooks()\n Threads.remove(self)\n self.status = 'Completed'\n return wrapper\n \n\n def _invoke_hooks(self) -> None:\n \"\"\"Invokes hooks in the thread\"\"\"\n errors: List[Tuple[Exception, str]] = []\n for hook in self.hooks:\n try:\n hook(self._returned_value)\n except Exception as e:\n if not any(isinstance(e, ignore) for ignore in self.ignore_errors):\n errors.append((\n e,\n hook.__name__\n ))\n\n if len(errors) > 0:\n self.errors.append(exceptions.HookRuntimeError(\n None, errors\n ))\n\n\n def _handle_exceptions(self) -> None:\n \"\"\"Raises exceptions if not suppressed in the main thread\"\"\"\n if self.suppress_errors:\n return\n \n for e in self.errors:\n raise e\n \n\n def global_trace(self, frame, event: str, arg) -> Optional[Callable]:\n if event == 'call':\n return self.local_trace\n \n def local_trace(self, frame, event: str, arg):\n if self.status == 'Kill Scheduled' and event == 'line':\n print('KILLED ident: %s' % self.ident)\n self.status = 'Killed'\n raise SystemExit()\n return self.local_trace\n \n def _run_with_trace(self) -> None:\n \"\"\"This will replace `threading.Thread`'s `run()` method\"\"\"\n if not self._run:\n raise exceptions.ThreadNotInitializedError('Running `_run_with_trace` may cause unintended behaviour, run `start` instead')\n \n sys.settrace(self.global_trace)\n self._run()\n \n\n @property\n def result(self) -> _Target_T:\n \"\"\"\n The return value of the thread\n \n Raises\n ------\n ThreadNotInitializedError: If the thread is not intialized\n ThreadNotRunningError: If the thread is not running\n ThreadStillRunningError: If the thread is still running\n \"\"\"\n if not self._initialized:\n raise exceptions.ThreadNotInitializedError()\n if self.status in ['Idle', 'Killed']:\n raise exceptions.ThreadNotRunningError()\n \n self._handle_exceptions()\n if self.status in ['Invoking hooks', 'Completed']:\n return self._returned_value\n else:\n raise exceptions.ThreadStillRunningError()\n \n \n def is_alive(self) -> bool:\n \"\"\"\n See if thread is still alive\n\n Raises\n ------\n ThreadNotInitializedError: If the thread is not intialized\n \"\"\"\n if not self._initialized:\n raise exceptions.ThreadNotInitializedError()\n return super().is_alive()\n \n\n def add_hook(self, hook: HookFunction[_Target_T]) -> None:\n \"\"\"\n Adds a hook to the thread\n -------------------------\n Hooks are executed automatically after a successful thread execution.\n The returned value is parsed directly into the hook\n\n Parameters\n ----------\n :param hook: This should be a function which takes the output value of `target` and should return None\n \"\"\"\n self.hooks.append(hook)\n\n\n def join(self, timeout: Optional[float] = None) -> bool:\n \"\"\"\n Halts the current thread execution until a thread completes or exceeds the timeout\n\n Parameters\n ----------\n :param timeout: The maximum time allowed to halt the thread\n\n Returns\n -------\n :returns bool: True if the thread is no-longer alive\n\n Raises\n ------\n ThreadNotInitializedError: If the thread is not initialized\n ThreadNotRunningError: If the thread is not running\n \"\"\"\n if not self._initialized:\n raise exceptions.ThreadNotInitializedError()\n \n if self.status == ['Idle', 'Killed']:\n raise exceptions.ThreadNotRunningError()\n\n super().join(timeout)\n self._handle_exceptions()\n return not self.is_alive()\n \n\n def get_return_value(self) -> _Target_T:\n \"\"\"\n Halts the current thread execution until the thread completes\n\n Returns\n -------\n :returns Any: The return value of the target function\n \"\"\"\n self.join()\n return self.result\n \n\n def kill(self, yielding: bool = False, timeout: float = 5) -> bool:\n \"\"\"\n Schedules a thread to be killed\n\n Parameters\n ----------\n :param yielding: If true, halts the current thread execution until the thread is killed\n :param timeout: The maximum number of seconds to wait before exiting\n\n Returns\n -------\n :returns bool: False if the it exceeded the timeout\n \n Raises\n ------\n ThreadNotInitializedError: If the thread is not initialized\n ThreadNotRunningError: If the thread is not running\n \"\"\"\n if not self.is_alive():\n raise exceptions.ThreadNotRunningError()\n \n self.status = 'Kill Scheduled'\n if not yielding:\n return True\n \n start = time.perf_counter()\n while self.status != 'Killed':\n time.sleep(0.01)\n if (time.perf_counter() - start) >= timeout:\n return False\n\n return True\n \n\n def start(self) -> None:\n \"\"\"\n Starts the thread\n \n Raises\n ------\n ThreadNotInitializedError: If the thread is not intialized\n ThreadStillRunningError: If there already is a running thread\n \"\"\"\n if self.is_alive():\n raise exceptions.ThreadStillRunningError()\n \n self._run = self.run\n self.run = self._run_with_trace\n super().start()" }, { "identifier": "Overflow_In", "path": "src/thread/_types.py", "snippet": "" } ]

[ { "identifier": "Base", "path": "models/base_model.py", "snippet": "class BaseModel:\n def __init__(self, *args, **kwargs):\n def __str__(self):\n def __repr__(self):\n def save(self):\n def to_dict(self):\n def delete(self):" }, { "identifier": "State", "path": "models/state.py", "snippet": "class State(BaseModel, Base):\n \"\"\"This is the class for State\n Attributes:\n name: input name\n \"\"\"\n __tablename__ = \"states\"\n name = Column(String(128), nullable=False)\n cities = relationship(\"City\", cascade='all, delete, delete-orphan',\n backref=\"state\")\n\n @property\n def cities(self):\n var = models.storage.all()\n lista = []\n result = []\n for key in var:\n city = key.replace('.', ' ')\n city = shlex.split(city)\n if (city[0] == 'City'):\n lista.append(var[key])\n for elem in lista:\n if (elem.state_id == self.id):\n result.append(elem)\n return (result)" }, { "identifier": "City", "path": "models/city.py", "snippet": "class City(BaseModel, Base):\n \"\"\"This is the class for City\n Attributes:\n state_id: The state id\n name: input name\n \"\"\"\n __tablename__ = \"cities\"\n name = Column(String(128), nullable=False)\n state_id = Column(String(60), ForeignKey('states.id'), nullable=False)\n places = relationship(\"Place\", cascade='all, delete, delete-orphan',\n backref=\"cities\")" }, { "identifier": "User", "path": "models/user.py", "snippet": "class User(BaseModel, Base):\n \"\"\"This is the class for user\n Attributes:\n email: email address\n password: password for you login\n first_name: first name\n last_name: last name\n \"\"\"\n __tablename__ = \"users\"\n email = Column(String(128), nullable=False)\n password = Column(String(128), nullable=False)\n first_name = Column(String(128))\n last_name = Column(String(128))\n places = relationship(\"Place\", cascade='all, delete, delete-orphan',\n backref=\"user\")\n reviews = relationship(\"Review\", cascade='all, delete, delete-orphan',\n backref=\"user\")" }, { "identifier": "Place", "path": "models/place.py", "snippet": "class Place(BaseModel, Base):\n \"\"\"This is the class for Place\n Attributes:\n city_id: city id\n user_id: user id\n name: name input\n description: string of description\n number_rooms: number of room in int\n number_bathrooms: number of bathrooms in int\n max_guest: maximum guest in int\n price_by_night:: pice for a staying in int\n latitude: latitude in flaot\n longitude: longitude in float\n amenity_ids: list of Amenity ids\n \"\"\"\n __tablename__ = \"places\"\n city_id = Column(String(60), ForeignKey(\"cities.id\"), nullable=False)\n user_id = Column(String(60), ForeignKey(\"users.id\"), nullable=False)\n name = Column(String(128), nullable=False)\n description = Column(String(1024))\n number_rooms = Column(Integer, nullable=False, default=0)\n number_bathrooms = Column(Integer, nullable=False, default=0)\n max_guest = Column(Integer, nullable=False, default=0)\n price_by_night = Column(Integer, nullable=False, default=0)\n latitude = Column(Float)\n longitude = Column(Float)\n amenity_ids = []\n\n if getenv(\"HBNB_TYPE_STORAGE\") == \"db\":\n reviews = relationship(\"Review\", cascade='all, delete, delete-orphan',\n backref=\"place\")\n\n amenities = relationship(\"Amenity\", secondary=place_amenity,\n viewonly=False,\n back_populates=\"place_amenities\")\n else:\n @property\n def reviews(self):\n \"\"\" Returns list of reviews.id \"\"\"\n var = models.storage.all()\n lista = []\n result = []\n for key in var:\n review = key.replace('.', ' ')\n review = shlex.split(review)\n if (review[0] == 'Review'):\n lista.append(var[key])\n for elem in lista:\n if (elem.place_id == self.id):\n result.append(elem)\n return (result)\n\n @property\n def amenities(self):\n \"\"\" Returns list of amenity ids \"\"\"\n return self.amenity_ids\n\n @amenities.setter\n def amenities(self, obj=None):\n \"\"\" Appends amenity ids to the attribute \"\"\"\n if type(obj) is Amenity and obj.id not in self.amenity_ids:\n self.amenity_ids.append(obj.id)" }, { "identifier": "Review", "path": "models/review.py", "snippet": "class Review(BaseModel, Base):\n \"\"\"This is the class for Review\n Attributes:\n place_id: place id\n user_id: user id\n text: review description\n \"\"\"\n __tablename__ = \"reviews\"\n text = Column(String(1024), nullable=False)\n place_id = Column(String(60), ForeignKey(\"places.id\"), nullable=False)\n user_id = Column(String(60), ForeignKey(\"users.id\"), nullable=False)" }, { "identifier": "Amenity", "path": "models/amenity.py", "snippet": "class Amenity(BaseModel, Base):\n \"\"\"This is the class for Amenity\n Attributes:\n name: input name\n \"\"\"\n __tablename__ = \"amenities\"\n name = Column(String(128), nullable=False)\n place_amenities = relationship(\"Place\", secondary=place_amenity)" } ]

[ { "identifier": "DVMTaskInterface", "path": "nostr_dvm/interfaces/dvmtaskinterface.py", "snippet": "class DVMTaskInterface:\n NAME: str\n KIND: int\n TASK: str = \"\"\n FIX_COST: float = 0\n PER_UNIT_COST: float = 0\n PRIVATE_KEY: str\n PUBLIC_KEY: str\n DVM = DVM\n SUPPORTS_ENCRYPTION = True # DVMs build with this framework support encryption, but others might not.\n ACCEPTS_CASHU = True # DVMs build with this framework support encryption, but others might not.\n dvm_config: DVMConfig\n admin_config: AdminConfig\n dependencies = []\n\n def __init__(self, name, dvm_config: DVMConfig, nip89config: NIP89Config, admin_config: AdminConfig = None,\n options=None, task=None):\n self.init(name, dvm_config, admin_config, nip89config, task)\n self.options = options\n self.install_dependencies(dvm_config)\n\n def init(self, name, dvm_config, admin_config=None, nip89config=None, task=None):\n self.NAME = name\n self.PRIVATE_KEY = dvm_config.PRIVATE_KEY\n if dvm_config.PUBLIC_KEY == \"\" or dvm_config.PUBLIC_KEY is None:\n dvm_config.PUBLIC_KEY = Keys.from_sk_str(dvm_config.PRIVATE_KEY).public_key().to_hex()\n self.PUBLIC_KEY = dvm_config.PUBLIC_KEY\n if dvm_config.FIX_COST is not None:\n self.FIX_COST = dvm_config.FIX_COST\n if dvm_config.PER_UNIT_COST is not None:\n self.PER_UNIT_COST = dvm_config.PER_UNIT_COST\n if task is not None:\n self.TASK = task\n\n dvm_config.SUPPORTED_DVMS = [self]\n dvm_config.DB = \"db/\" + self.NAME + \".db\"\n if nip89config.KIND is not None:\n self.KIND = nip89config.KIND\n\n dvm_config.NIP89 = self.NIP89_announcement(nip89config)\n self.dvm_config = dvm_config\n self.admin_config = admin_config\n\n def install_dependencies(self, dvm_config):\n if dvm_config.SCRIPT != \"\":\n if self.dvm_config.USE_OWN_VENV:\n dir = r'cache/venvs/' + os.path.basename(dvm_config.SCRIPT).split(\".py\")[0]\n pip_location = 'bin/pip'\n if platform == \"win32\":\n pip_location = dir + '/Scripts/pip'\n\n if not os.path.isdir(dir):\n print(\"Creating Venv: \" + dir)\n create(dir, with_pip=True, upgrade_deps=True)\n self.dependencies.append((\"nostr-dvm\", \"nostr-dvm\"))\n for (module, package) in self.dependencies:\n print(\"Installing Venv Module: \" + module)\n run([pip_location, \"install\", \"--upgrade\", package], cwd=dir)\n else:\n for module, package in self.dependencies:\n if module != \"nostr-dvm\":\n try:\n __import__(module)\n except ImportError:\n print(\"Installing global Module: \" + module)\n subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", package])\n\n def run(self):\n nostr_dvm_thread = Thread(target=self.DVM, args=[self.dvm_config, self.admin_config])\n nostr_dvm_thread.start()\n\n def NIP89_announcement(self, nip89config: NIP89Config):\n nip89 = NIP89Config()\n nip89.NAME = self.NAME\n nip89.KIND = self.KIND\n nip89.PK = self.PRIVATE_KEY\n nip89.DTAG = nip89config.DTAG\n nip89.CONTENT = nip89config.CONTENT\n return nip89\n\n def is_input_supported(self, tags, client=None, dvm_config=None) -> bool:\n \"\"\"Check if input is supported for current Task.\"\"\"\n pass\n\n def create_request_from_nostr_event(self, event, client=None, dvm_config=None) -> dict:\n \"\"\"Parse input into a request form that will be given to the process method\"\"\"\n pass\n\n def process(self, request_form):\n \"Process the data and return the result\"\n pass\n\n def post_process(self, result, event):\n \"\"\"Post-process the data and return the result Use default function, if not overwritten\"\"\"\n return post_process_result(result, event)\n\n @staticmethod\n def set_options(request_form):\n print(\"Setting options...\")\n opts = []\n if request_form.get(\"options\"):\n opts = json.loads(request_form[\"options\"])\n print(opts)\n return dict(opts)\n\n @staticmethod\n def process_args():\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument('--request', dest='request')\n parser.add_argument('--identifier', dest='identifier')\n parser.add_argument('--output', dest='output')\n args = parser.parse_args()\n return args\n\n @staticmethod\n def write_output(result, output):\n with open(os.path.abspath(output), 'w') as f:\n f.write(result)\n # f.close()" }, { "identifier": "process_venv", "path": "nostr_dvm/interfaces/dvmtaskinterface.py", "snippet": "def process_venv(identifier):\n args = DVMTaskInterface.process_args()\n dvm_config = build_default_config(args.identifier)\n dvm = identifier(name=\"\", dvm_config=dvm_config, nip89config=NIP89Config(), admin_config=None)\n try:\n result = dvm.process(json.loads(args.request))\n DVMTaskInterface.write_output(result, args.output)\n except Exception as e:\n DVMTaskInterface.write_output(\"Error: \" + str(e), args.output)" }, { "identifier": "AdminConfig", "path": "nostr_dvm/utils/admin_utils.py", "snippet": "class AdminConfig:\n REBROADCAST_NIP89: bool = False\n UPDATE_PROFILE: bool = False\n DELETE_NIP89: bool = False\n WHITELISTUSER: bool = False\n UNWHITELISTUSER: bool = False\n BLACKLISTUSER: bool = False\n DELETEUSER: bool = False\n LISTDATABASE: bool = False\n ClEANDB: bool = False\n\n USERNPUB: str = \"\"\n LUD16: str = \"\"\n\n EVENTID: str = \"\"\n PRIVKEY: str = \"\"" }, { "identifier": "EventDefinitions", "path": "nostr_dvm/utils/definitions.py", "snippet": "class EventDefinitions:\n KIND_DM = 4\n KIND_ZAP = 9735\n KIND_ANNOUNCEMENT = 31990\n KIND_NIP94_METADATA = 1063\n KIND_FEEDBACK = 7000\n KIND_NIP90_EXTRACT_TEXT = 5000\n KIND_NIP90_RESULT_EXTRACT_TEXT = KIND_NIP90_EXTRACT_TEXT + 1000\n KIND_NIP90_SUMMARIZE_TEXT = 5001\n KIND_NIP90_RESULT_SUMMARIZE_TEXT = KIND_NIP90_SUMMARIZE_TEXT + 1000\n KIND_NIP90_TRANSLATE_TEXT = 5002\n KIND_NIP90_RESULT_TRANSLATE_TEXT = KIND_NIP90_TRANSLATE_TEXT + 1000\n KIND_NIP90_GENERATE_TEXT = 5050\n KIND_NIP90_RESULT_GENERATE_TEXT = KIND_NIP90_GENERATE_TEXT + 1000\n KIND_NIP90_GENERATE_IMAGE = 5100\n KIND_NIP90_RESULT_GENERATE_IMAGE = KIND_NIP90_GENERATE_IMAGE + 1000\n KIND_NIP90_CONVERT_VIDEO = 5200\n KIND_NIP90_RESULT_CONVERT_VIDEO = KIND_NIP90_CONVERT_VIDEO + 1000\n KIND_NIP90_GENERATE_VIDEO = 5202\n KIND_NIP90_TEXT_TO_SPEECH = 5250\n KIND_NIP90_RESULT_TEXT_TO_SPEECH = KIND_NIP90_TEXT_TO_SPEECH + 1000\n KIND_NIP90_RESULT_GENERATE_VIDEO = KIND_NIP90_GENERATE_VIDEO + 1000\n KIND_NIP90_CONTENT_DISCOVERY = 5300\n KIND_NIP90_RESULT_CONTENT_DISCOVERY = KIND_NIP90_CONTENT_DISCOVERY + 1000\n KIND_NIP90_PEOPLE_DISCOVERY = 5301\n KIND_NIP90_RESULT_PEOPLE_DISCOVERY = KIND_NIP90_PEOPLE_DISCOVERY + 1000\n KIND_NIP90_CONTENT_SEARCH = 5302\n KIND_NIP90_RESULTS_CONTENT_SEARCH = KIND_NIP90_CONTENT_SEARCH + 1000\n KIND_NIP90_GENERIC = 5999\n KIND_NIP90_RESULT_GENERIC = KIND_NIP90_GENERIC + 1000\n ANY_RESULT = [KIND_NIP90_RESULT_EXTRACT_TEXT,\n KIND_NIP90_RESULT_SUMMARIZE_TEXT,\n KIND_NIP90_RESULT_TRANSLATE_TEXT,\n KIND_NIP90_RESULT_GENERATE_TEXT,\n KIND_NIP90_RESULT_GENERATE_IMAGE,\n KIND_NIP90_CONTENT_DISCOVERY,\n KIND_NIP90_PEOPLE_DISCOVERY,\n KIND_NIP90_RESULT_CONVERT_VIDEO,\n KIND_NIP90_RESULT_CONTENT_DISCOVERY,\n KIND_NIP90_RESULT_PEOPLE_DISCOVERY,\n KIND_NIP90_RESULT_GENERATE_VIDEO,\n KIND_NIP90_RESULT_GENERIC]" }, { "identifier": "DVMConfig", "path": "nostr_dvm/utils/dvmconfig.py", "snippet": "class DVMConfig:\n SUPPORTED_DVMS = []\n PRIVATE_KEY: str = \"\"\n PUBLIC_KEY: str = \"\"\n FIX_COST: float = None\n PER_UNIT_COST: float = None\n\n RELAY_LIST = [\"wss://relay.damus.io\", \"wss://nostr-pub.wellorder.net\", \"wss://nos.lol\", \"wss://nostr.wine\",\n \"wss://nostr.mom\", \"wss://nostr.oxtr.dev\", \"wss://relay.nostr.bg\",\n \"wss://relay.f7z.io\", \"wss://pablof7z.nostr1.com\", \"wss://relay.nostr.net\", \"wss://140.f7z.io\",\n \"wss://relay.snort.social\", \"wss://offchain.pub/\", \"wss://relay.nostr.band\"]\n\n RELAY_TIMEOUT = 5\n EXTERNAL_POST_PROCESS_TYPE = PostProcessFunctionType.NONE # Leave this on None, except the DVM is external\n LNBITS_INVOICE_KEY = '' # Will all automatically generated by default, or read from .env\n LNBITS_ADMIN_KEY = '' # In order to pay invoices, e.g. from the bot to DVMs, or reimburse users.\n LNBITS_URL = 'https://lnbits.com'\n LN_ADDRESS = ''\n SCRIPT = ''\n IDENTIFIER = ''\n USE_OWN_VENV = True # Make an own venv for each dvm's process function.Disable if you want to install packages into main venv. Only recommended if you dont want to run dvms with different dependency versions\n DB: str\n NEW_USER_BALANCE: int = 0 # Free credits for new users\n NIP89: NIP89Config\n SHOW_RESULT_BEFORE_PAYMENT: bool = False # if this is true show results even when not paid right after autoprocess" }, { "identifier": "build_default_config", "path": "nostr_dvm/utils/dvmconfig.py", "snippet": "def build_default_config(identifier):\n dvm_config = DVMConfig()\n dvm_config.PRIVATE_KEY = check_and_set_private_key(identifier)\n dvm_config.IDENTIFIER = identifier\n npub = Keys.from_sk_str(dvm_config.PRIVATE_KEY).public_key().to_bech32()\n invoice_key, admin_key, wallet_id, user_id, lnaddress = check_and_set_ln_bits_keys(identifier, npub)\n dvm_config.LNBITS_INVOICE_KEY = invoice_key\n dvm_config.LNBITS_ADMIN_KEY = admin_key # The dvm might pay failed jobs back\n dvm_config.LNBITS_URL = os.getenv(\"LNBITS_HOST\")\n dvm_config.LN_ADDRESS = lnaddress\n return dvm_config" }, { "identifier": "NIP89Config", "path": "nostr_dvm/utils/nip89_utils.py", "snippet": "class NIP89Config:\n DTAG: str = \"\"\n NAME: str = \"\"\n KIND: int = None\n PK: str = \"\"\n CONTENT: str = \"\"" }, { "identifier": "check_and_set_d_tag", "path": "nostr_dvm/utils/nip89_utils.py", "snippet": "def check_and_set_d_tag(identifier, name, pk, imageurl):\n if not os.getenv(\"NIP89_DTAG_\" + identifier.upper()):\n new_dtag = nip89_create_d_tag(name, Keys.from_sk_str(pk).public_key().to_hex(),\n imageurl)\n nip89_add_dtag_to_env_file(\"NIP89_DTAG_\" + identifier.upper(), new_dtag)\n print(\"Some new dtag:\" + new_dtag)\n return new_dtag\n else:\n return os.getenv(\"NIP89_DTAG_\" + identifier.upper())" }, { "identifier": "post_process_list_to_events", "path": "nostr_dvm/utils/output_utils.py", "snippet": "def post_process_list_to_events(result):\n result_list = json.loads(result)\n result_str = \"\"\n if len(result_list) == 0:\n return \"No results found\"\n for tag in result_list:\n e_tag = Tag.parse(tag)\n result_str = result_str + \"nostr:\" + EventId.from_hex(\n e_tag.as_vec()[1]).to_bech32() + \"\\n\"\n return result_str" } ]

[ { "identifier": "ArgModelMismatch", "path": "meme_generator/exception.py", "snippet": "class ArgModelMismatch(ArgMismatch):\n status_code: int = 552\n\n def __init__(self, meme_key: str, error_message: str):\n self.error_message = error_message\n message = f\"Argument model validation failed: {self.error_message}\"\n super().__init__(meme_key, message)" }, { "identifier": "ArgParserExit", "path": "meme_generator/exception.py", "snippet": "class ArgParserExit(ArgMismatch):\n status_code: int = 551\n\n def __init__(self, meme_key: str, error_message: str):\n self.error_message = error_message\n message = f\"Argument parser failed to parse: {self.error_message}\"\n super().__init__(meme_key, message)" }, { "identifier": "ImageNumberMismatch", "path": "meme_generator/exception.py", "snippet": "class ImageNumberMismatch(ParamsMismatch):\n status_code: int = 541\n\n def __init__(self, meme_key: str, min_images: int = 0, max_images: int = 0):\n message = (\n \"The number of images is incorrect, \"\n f\"it should be no less than {min_images} and no more than {max_images}\"\n )\n super().__init__(meme_key, message)" }, { "identifier": "OpenImageFailed", "path": "meme_generator/exception.py", "snippet": "class OpenImageFailed(MemeGeneratorException):\n status_code: int = 533\n\n def __init__(self, error_message: str):\n self.error_message = error_message\n message = f'Error opening images: \"{self.error_message}\"'\n super().__init__(message)" }, { "identifier": "ParserExit", "path": "meme_generator/exception.py", "snippet": "class ParserExit(MemeGeneratorException):\n status_code: int = 534\n\n def __init__(self, status: int = 0, error_message: Optional[str] = None):\n self.status = status\n self.error_message = error_message or \"\"\n message = (\n f\"Argument parser failed to parse. (status={self.status}\"\n + (f\", message={self.error_message!r}\" if self.error_message else \"\")\n + \")\"\n )\n super().__init__(message)" }, { "identifier": "TextNumberMismatch", "path": "meme_generator/exception.py", "snippet": "class TextNumberMismatch(ParamsMismatch):\n status_code: int = 542\n\n def __init__(self, meme_key: str, min_texts: int = 0, max_texts: int = 0):\n message = (\n \"The number of texts is incorrect, \"\n f\"it should be no less than {min_texts} and no more than {max_texts}\"\n )\n super().__init__(meme_key, message)" }, { "identifier": "TextOrNameNotEnough", "path": "meme_generator/exception.py", "snippet": "class TextOrNameNotEnough(ParamsMismatch):\n status_code: int = 543\n\n def __init__(self, meme_key: str, message: Optional[str] = None):\n message = message or \"The number of texts or user names is not enough\"\n super().__init__(meme_key, message)" }, { "identifier": "is_coroutine_callable", "path": "meme_generator/utils.py", "snippet": "def is_coroutine_callable(call: Callable[..., Any]) -> bool:\n \"\"\"检查 call 是否是一个 callable 协程函数\"\"\"\n if inspect.isroutine(call):\n return inspect.iscoroutinefunction(call)\n if inspect.isclass(call):\n return False\n func_ = getattr(call, \"__call__\", None)\n return inspect.iscoroutinefunction(func_)" }, { "identifier": "random_image", "path": "meme_generator/utils.py", "snippet": "def random_image() -> BytesIO:\n text = random.choice([\"😂\", \"😅\", \"🤗\", \"🤤\", \"🥵\", \"🥰\", \"😍\", \"😭\", \"😋\", \"😏\"])\n return (\n BuildImage.new(\"RGBA\", (500, 500), \"white\")\n .draw_text((0, 0, 500, 500), text, max_fontsize=400)\n .save_png()\n )" }, { "identifier": "random_text", "path": "meme_generator/utils.py", "snippet": "def random_text() -> str:\n return random.choice([\"刘一\", \"陈二\", \"张三\", \"李四\", \"王五\", \"赵六\", \"孙七\", \"周八\", \"吴九\", \"郑十\"])" }, { "identifier": "run_sync", "path": "meme_generator/utils.py", "snippet": "def run_sync(call: Callable[P, R]) -> Callable[P, Coroutine[None, None, R]]:\n \"\"\"一个用于包装 sync function 为 async function 的装饰器\n 参数:\n call: 被装饰的同步函数\n \"\"\"\n\n @wraps(call)\n async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:\n loop = asyncio.get_running_loop()\n pfunc = partial(call, *args, **kwargs)\n result = await loop.run_in_executor(None, pfunc)\n return result\n\n return _wrapper" } ]

[ { "identifier": "Model", "path": "models/yolo.py", "snippet": "class Model(nn.Module):\n def __init__(self, model_cfg='yolov5s.yaml', ch=3, nc=None): # model, input channels, number of classes\n super(Model, self).__init__()\n if type(model_cfg) is dict:\n self.md = model_cfg # model dict\n else: # is *.yaml\n with open(model_cfg) as f:\n self.md = yaml.load(f, Loader=yaml.FullLoader) # model dict\n\n # Define model\n if nc:\n self.md['nc'] = nc # override yaml value\n self.model, self.save = parse_model(self.md, ch=[ch]) # model, savelist, ch_out\n # print([x.shape for x in self.forward(torch.zeros(1, ch, 64, 64))])\n\n # Build strides, anchors\n m = self.model[-1] # Detect()\n m.stride = torch.tensor([64 / x.shape[-2] for x in self.forward(torch.zeros(1, ch, 64, 64))]) # forward\n m.anchors /= m.stride.view(-1, 1, 1)\n self.stride = m.stride\n\n # Init weights, biases\n torch_utils.initialize_weights(self)\n self._initialize_biases() # only run once\n torch_utils.model_info(self)\n print('')\n\n def forward(self, x, augment=False, profile=False):\n if augment:\n img_size = x.shape[-2:] # height, width\n s = [0.83, 0.67] # scales\n y = []\n for i, xi in enumerate((x,\n torch_utils.scale_img(x.flip(3), s[0]), # flip-lr and scale\n torch_utils.scale_img(x, s[1]), # scale\n )):\n # cv2.imwrite('img%g.jpg' % i, 255 * xi[0].numpy().transpose((1, 2, 0))[:, :, ::-1])\n y.append(self.forward_once(xi)[0])\n\n y[1][..., :4] /= s[0] # scale\n y[1][..., 0] = img_size[1] - y[1][..., 0] # flip lr\n y[2][..., :4] /= s[1] # scale\n return torch.cat(y, 1), None # augmented inference, train\n else:\n return self.forward_once(x, profile) # single-scale inference, train\n\n def forward_once(self, x, profile=False):\n y, dt = [], [] # outputs\n for m in self.model:\n if m.f != -1: # if not from previous layer\n x = y[m.f] if isinstance(m.f, int) else [x if j == -1 else y[j] for j in m.f] # from earlier layers\n\n if profile:\n import thop\n o = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # FLOPS\n t = torch_utils.time_synchronized()\n for _ in range(10):\n _ = m(x)\n dt.append((torch_utils.time_synchronized() - t) * 100)\n print('%10.1f%10.0f%10.1fms %-40s' % (o, m.np, dt[-1], m.type))\n\n x = m(x) # run\n y.append(x if m.i in self.save else None) # save output\n\n if profile:\n print('%.1fms total' % sum(dt))\n return x\n\n def _initialize_biases(self, cf=None): # initialize biases into Detect(), cf is class frequency\n # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1.\n m = self.model[-1] # Detect() module\n for f, s in zip(m.f, m.stride): #  from\n mi = self.model[f % m.i]\n b = mi.bias.view(m.na, -1) # conv.bias(255) to (3,85)\n with torch.no_grad():\n b[:, 4] += math.log(8 / (640 / s) ** 2) # obj (8 objects per 640 image)\n b[:, 5:] += math.log(0.6 / (m.nc - 0.99)) if cf is None else torch.log(cf / cf.sum()) # cls\n mi.bias = torch.nn.Parameter(b.view(-1), requires_grad=True)\n\n def _print_biases(self):\n m = self.model[-1] # Detect() module\n for f in sorted([x % m.i for x in m.f]): #  from\n b = self.model[f].bias.detach().view(m.na, -1).T # conv.bias(255) to (3,85)\n print(('%g Conv2d.bias:' + '%10.3g' * 6) % (f, *b[:5].mean(1).tolist(), b[5:].mean()))\n\n # def _print_weights(self):\n # for m in self.model.modules():\n # if type(m) is Bottleneck:\n # print('%10.3g' % (m.w.detach().sigmoid() * 2)) # shortcut weights\n\n def fuse(self): # fuse model Conv2d() + BatchNorm2d() layers\n print('Fusing layers...')\n for m in self.model.modules():\n if type(m) is Conv:\n m.conv = torch_utils.fuse_conv_and_bn(m.conv, m.bn) # update conv\n m.bn = None # remove batchnorm\n m.forward = m.fuseforward # update forward\n torch_utils.model_info(self)" }, { "identifier": "google_utils", "path": "utils/google_utils.py", "snippet": "def attempt_download(weights):\ndef gdrive_download(id='1HaXkef9z6y5l4vUnCYgdmEAj61c6bfWO', name='coco.zip'):" } ]

[ { "identifier": "log", "path": "src/log.py", "snippet": "def setup_custom_logger(name: str = \"benchmark\"):" }, { "identifier": "BenchmarkCallback", "path": "src/callbacks.py", "snippet": "class BenchmarkCallback(Callback):\n def __init__(\n self,\n model_name: str,\n precision: str,\n workers: int,\n warmup_steps: int = 50,\n ):\n self.warmup_steps = warmup_steps\n self.start_time = 0\n self.end_time = 0\n self.precision = precision\n self.model = model_name\n self.workers = workers\n\n def on_fit_start(self, trainer, pl_module):\n logger.info(\n f\"Benchmark started. Number of warmup iterations: {self.warmup_steps}\"\n )\n\n def on_train_batch_start(self, trainer, pl_module, batch, batch_idx: int):\n if batch_idx == self.warmup_steps:\n logger.info(\n f\"Completed {self.warmup_steps} warmup steps. Benchmark timer started.\"\n )\n self.start_time = time.time()\n\n def on_fit_end(self, trainer, pl_module):\n self.end_time = time.time()\n logger.info(\"Fit function finished\")\n\n dataset = trainer.train_dataloader.dataset\n batch_size = trainer.train_dataloader.batch_size\n in_w, in_h = dataset.width, dataset.height\n\n benchmark_steps = trainer.global_step - self.warmup_steps\n processed_megapixels = (\n trainer.world_size * in_w * in_h * batch_size * benchmark_steps / 1e6\n )\n\n elapsed_time = (\n self.end_time - self.start_time\n ) + 1e-7 # for numerical stability\n mpx_s = processed_megapixels / (elapsed_time)\n\n processed_imgs = batch_size * benchmark_steps * trainer.world_size\n images_s = processed_imgs / (elapsed_time)\n\n batches_s = benchmark_steps * trainer.world_size / elapsed_time\n\n logger.info(f\"Benchmark finished in {elapsed_time:.1f} seconds\")\n logger.info(\n f\"Average training throughput: {mpx_s:.2f} MPx/s (megapixels per second) | \"\n + f\"{images_s:.2f} images/s | {batches_s:.2f} batches/s\"\n )\n\n os.makedirs(\"./benchmarks\", exist_ok=True)\n csv_path = os.path.join(\"./benchmarks\", \"benchmark.csv\")\n file_exists = os.path.isfile(csv_path) and os.stat(csv_path).st_size >= 0\n with open(csv_path, \"a\") as file:\n writer = csv.writer(file)\n if not file_exists:\n writer.writerow(\n [\n \"Datetime\",\n \"GPU\",\n \"cuDNN version\",\n \"N GPUs\",\n \"Data Loader workers\",\n \"Model\",\n \"Precision\",\n \"Minibatch\",\n \"Input width [px]\",\n \"Input height [px]\",\n \"Warmup steps\",\n \"Benchmark steps\",\n \"MPx/s\",\n \"images/s\",\n \"batches/s\",\n ]\n )\n\n data = [\n datetime.now().strftime(\"%d/%m/%Y %H:%M:%S\"),\n torch.cuda.get_device_name(0),\n torch.backends.cudnn.version(),\n trainer.world_size,\n self.workers,\n self.model,\n self.precision,\n batch_size,\n in_w,\n in_h,\n self.warmup_steps,\n benchmark_steps,\n mpx_s,\n images_s,\n batches_s,\n ]\n writer.writerow(data)\n logger.info(\n \"Written benchmark data to a CSV file. \"\n + \"See 'Logging Results to a Persisent CSV File' section to \"\n + \"save the file on your disk: \"\n + \"https://github.com/tensorpix/benchmarking-cv-models#logging-results-to-a-persistent-csv-file\"\n )\n\n try:\n os.chmod(\n csv_path,\n stat.S_IRUSR\n | stat.S_IRGRP\n | stat.S_IWUSR\n | stat.S_IROTH\n | stat.S_IWOTH,\n )\n except Exception as e:\n logger.error(f\"Failed to change csv permissions: {e}\")" }, { "identifier": "InMemoryDataset", "path": "src/data/in_memory_dataset.py", "snippet": "class InMemoryDataset(Dataset):\n def __init__(\n self,\n width: int = 224,\n height: int = 224,\n n_channels: int = 3,\n dataset_size: int = int(1e7),\n ):\n super().__init__()\n self.width = width\n self.height = height\n self.n_channels = n_channels\n self.dataset_size = dataset_size\n\n def __len__(self):\n return self.dataset_size\n\n def __getitem__(self, idx: int) -> torch.Tensor:\n \"\"\"\n Must return a tensor of shape C x H x W with values in [0, 1] range.\n \"\"\"\n return torch.rand(self.n_channels, self.height, self.width, dtype=torch.float32)" }, { "identifier": "LitClassification", "path": "src/models/lightning_modules.py", "snippet": "class LitClassification(L.LightningModule):\n def __init__(self, model: nn.Module, optimizer=torch.optim.Adam):\n super().__init__()\n self.model = model\n self.loss = nn.CrossEntropyLoss()\n self.optimizer = optimizer\n\n def training_step(self, batch, batch_idx) -> torch.Tensor:\n y_hat = self.model(batch)\n y = torch.rand_like(y_hat)\n\n loss = self.loss(y_hat, y)\n return loss\n\n def configure_optimizers(self):\n return self.optimizer(self.parameters(), lr=2e-5)" } ]

[ { "identifier": "NotFound", "path": "aquilify/exception/base.py", "snippet": "class NotFound(Response, HTTPException):\n def __init__(self, status_code=404):\n super().__init__(error404(), status_code=status_code, content_type=\"text/html\")" }, { "identifier": "Unauthorized", "path": "aquilify/exception/base.py", "snippet": "class Unauthorized(Response, HTTPException):\n def __init__(self, detail=\"Unauthorized\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=401, content_type='text/html')" }, { "identifier": "Forbidden", "path": "aquilify/exception/base.py", "snippet": "class Forbidden(Response, HTTPException):\n def __init__(self, detail=\"\"):\n self.detail = error403(detail)\n super().__init__(content=self.detail, status_code=403, content_type='text/html')" }, { "identifier": "BadGateway", "path": "aquilify/exception/base.py", "snippet": "class BadGateway(Response, HTTPException):\n def __init__(self, detail=\"Bad Gateway\"):\n self.detail = error502()\n super().__init__(content=self.detail, status_code=502, content_type='text/html')" }, { "identifier": "InternalServerError", "path": "aquilify/exception/base.py", "snippet": "class InternalServerError(Response, HTTPException):\n def __init__(self, detail=\"Internal Server Error\"):\n self.detail = error500(detail)\n super().__init__(content=self.detail, status_code=500, content_type='text/html')" }, { "identifier": "MethodNotAllowed", "path": "aquilify/exception/base.py", "snippet": "class MethodNotAllowed(Response, HTTPException):\n def __init__(self, allowed_methods=None):\n super().__init__(content=error405(), status_code=405, content_type='text/html')" }, { "identifier": "BadRequest", "path": "aquilify/exception/base.py", "snippet": "class BadRequest(Response, HTTPException):\n def __init__(self, detail=\"Bad Request\", exception=None):\n self.detail = error400()\n self.exception = exception\n super().__init__(content=detail, status_code=400, content_type='text/html')" }, { "identifier": "NotAcceptable", "path": "aquilify/exception/base.py", "snippet": "class NotAcceptable(Response, HTTPException):\n def __init__(self, detail=\"Not Acceptable\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=406, content_type='text/html')" }, { "identifier": "ProxyAuthenticationRequired", "path": "aquilify/exception/base.py", "snippet": "class ProxyAuthenticationRequired(Response, HTTPException):\n def __init__(self, detail=\"Proxy Authentication Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=407, content_type='text/html')" }, { "identifier": "RequestTimeout", "path": "aquilify/exception/base.py", "snippet": "class RequestTimeout(Response, HTTPException):\n def __init__(self, detail=\"Request Timeout\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=408, content_type='text/html')" }, { "identifier": "Conflict", "path": "aquilify/exception/base.py", "snippet": "class Conflict(Response, HTTPException):\n def __init__(self, detail=\"Conflict\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=409, content_type='text/html')" }, { "identifier": "Gone", "path": "aquilify/exception/base.py", "snippet": "class Gone(Response, HTTPException):\n def __init__(self, detail=\"Gone\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=410, content_type='text/html')" }, { "identifier": "LengthRequired", "path": "aquilify/exception/base.py", "snippet": "class LengthRequired(Response, HTTPException):\n def __init__(self, detail=\"Length Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=411, content_type='text/html')" }, { "identifier": "PreconditionFailed", "path": "aquilify/exception/base.py", "snippet": "class PreconditionFailed(Response, HTTPException):\n def __init__(self, detail=\"Precondition Failed\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=412, content_type='text/html')" }, { "identifier": "RequestURITooLong", "path": "aquilify/exception/base.py", "snippet": "class RequestURITooLong(Response, HTTPException):\n def __init__(self, detail=\"Request-URI Too Long\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=414, content_type='text/html')" }, { "identifier": "UnsupportedMediaType", "path": "aquilify/exception/base.py", "snippet": "class UnsupportedMediaType(Response, HTTPException):\n def __init__(self, detail=\"Unsupported Media Type\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=415, content_type='text/html')" }, { "identifier": "RequestedRangeNotSatisfiable", "path": "aquilify/exception/base.py", "snippet": "class RequestedRangeNotSatisfiable(Response, HTTPException):\n def __init__(self, detail=\"Requested Range Not Satisfiable\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=416, content_type='text/html')" }, { "identifier": "ExpectationFailed", "path": "aquilify/exception/base.py", "snippet": "class ExpectationFailed(Response, HTTPException):\n def __init__(self, detail=\"Expectation Failed\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=417, content_type='text/html')" }, { "identifier": "UnprocessableEntity", "path": "aquilify/exception/base.py", "snippet": "class UnprocessableEntity(Response, HTTPException):\n def __init__(self, detail=\"Unprocessable Entity\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=422, content_type='text/html')" }, { "identifier": "MisdirectedRequest", "path": "aquilify/exception/base.py", "snippet": "class MisdirectedRequest(Response, HTTPException):\n def __init__(self, detail=\"Misdirected Request\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=421, content_type='text/html')" }, { "identifier": "Locked", "path": "aquilify/exception/base.py", "snippet": "class Locked(Response, HTTPException):\n def __init__(self, detail=\"Locked\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=423, content_type='text/html')" }, { "identifier": "FailedDependency", "path": "aquilify/exception/base.py", "snippet": "class FailedDependency(Response, HTTPException):\n def __init__(self, detail=\"Failed Dependency\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=424, content_type='text/html')" }, { "identifier": "UpgradeRequired", "path": "aquilify/exception/base.py", "snippet": "class UpgradeRequired(Response, HTTPException):\n def __init__(self, detail=\"Upgrade Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=426, content_type='text/html')" }, { "identifier": "TooManyRequests", "path": "aquilify/exception/base.py", "snippet": "class TooManyRequests(Response, HTTPException):\n def __init__(self, detail=\"\"):\n self.detail = error429(detail)\n super().__init__(content=self.detail, status_code=429, content_type='text/html')" }, { "identifier": "RequestHeaderFieldsTooLarge", "path": "aquilify/exception/base.py", "snippet": "class RequestHeaderFieldsTooLarge(Response, HTTPException):\n def __init__(self, detail=\"Request Header Fields Too Large\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=431, content_type='text/html')" }, { "identifier": "UnavailableForLegalReasons", "path": "aquilify/exception/base.py", "snippet": "class UnavailableForLegalReasons(Response, HTTPException):\n def __init__(self, detail=\"Unavailable For Legal Reasons\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=451, content_type='text/html')" }, { "identifier": "ServiceUnavailable", "path": "aquilify/exception/base.py", "snippet": "class ServiceUnavailable(Response, HTTPException):\n def __init__(self, detail=\"Service Unavailable\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=503, content_type='text/html')" }, { "identifier": "NotImplemented", "path": "aquilify/exception/base.py", "snippet": "class NotImplemented(Response, HTTPException):\n def __init__(self, detail=\"Not Implemented\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=501, content_type='text/html')" }, { "identifier": "GatewayTimeout", "path": "aquilify/exception/base.py", "snippet": "class GatewayTimeout(Response, HTTPException):\n def __init__(self, detail=\"Gateway Timeout\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=504, content_type='text/html')" }, { "identifier": "HTTPVersionNotSupported", "path": "aquilify/exception/base.py", "snippet": "class HTTPVersionNotSupported(Response, HTTPException):\n def __init__(self, detail=\"HTTP Version Not Supported\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=505, content_type='text/html')" }, { "identifier": "VariantAlsoNegotiates", "path": "aquilify/exception/base.py", "snippet": "class VariantAlsoNegotiates(Response, HTTPException):\n def __init__(self, detail=\"Variant Also Negotiates\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=506, content_type='text/html')" }, { "identifier": "InsufficientStorage", "path": "aquilify/exception/base.py", "snippet": "class InsufficientStorage(Response, HTTPException):\n def __init__(self, detail=\"Insufficient Storage\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=507, content_type='text/html')" }, { "identifier": "LoopDetected", "path": "aquilify/exception/base.py", "snippet": "class LoopDetected(Response, HTTPException):\n def __init__(self, detail=\"Loop Detected\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=508, content_type='text/html')" }, { "identifier": "NotExtended", "path": "aquilify/exception/base.py", "snippet": "class NotExtended(Response, HTTPException):\n def __init__(self, detail=\"Not Extended\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=510, content_type='text/html')" }, { "identifier": "NetworkAuthenticationRequired", "path": "aquilify/exception/base.py", "snippet": "class NetworkAuthenticationRequired(Response, HTTPException):\n def __init__(self, detail=\"Network Authentication Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=511, content_type='text/html')" }, { "identifier": "PaymentRequired", "path": "aquilify/exception/base.py", "snippet": "class PaymentRequired(Response, HTTPException):\n def __init__(self, detail=\"Payement Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=402, content_type='text/html')" }, { "identifier": "PayloadTooLarge", "path": "aquilify/exception/base.py", "snippet": "class PayloadTooLarge(Response, HTTPException):\n def __init__(self, detail=\"Payload Too Large\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=413, content_type='text/html')" }, { "identifier": "ImATeapot", "path": "aquilify/exception/base.py", "snippet": "class ImATeapot(Response, HTTPException):\n def __init__(self, detail=\"ImATeapot\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=418, content_type='text/html')" }, { "identifier": "PreconditionRequired", "path": "aquilify/exception/base.py", "snippet": "class PreconditionRequired(Response, HTTPException):\n def __init__(self, detail=\"Preconditional Required\"):\n self.detail = f\"\"\"<h1>{detail}</h1>\"\"\"\n super().__init__(content=self.detail, status_code=428, content_type='text/html')" } ]

[ { "identifier": "InsertAfterImportsVisitor", "path": "src/django_autotyping/stubbing/codemods/base.py", "snippet": "class InsertAfterImportsVisitor(ContextAwareTransformer):\n \"\"\"Insert a list of statements after imports.\"\"\"\n\n CONTEXT_KEY = \"InsertAfterImportsVisitor\"\n\n @classmethod\n def insert_after_imports(\n cls,\n context: CodemodContext,\n statements: Sequence[cst.SimpleStatementLine | cst.BaseCompoundStatement],\n ) -> None:\n \"\"\"Insert a list of statements following the module imports.\n\n If no imports are to be found, statements will be added at the beginning of the module.\"\"\"\n ctx_statements = context.scratch.get(cls.CONTEXT_KEY, [])\n ctx_statements.extend(statements)\n context.scratch[cls.CONTEXT_KEY] = ctx_statements\n\n def leave_Module(self, original_node: cst.Module, updated_node: cst.Module) -> cst.Module:\n statements = self.context.scratch.get(self.CONTEXT_KEY, [])\n if not statements:\n return updated_node\n\n body = list(updated_node.body)\n\n last_import = next((node for node in reversed(body) if m.matches(node, IMPORT_MATCHER)), None)\n index = body.index(last_import) + 1 if last_import is not None else 0\n body[index:index] = statements\n\n return updated_node.with_changes(\n body=body,\n )" }, { "identifier": "StubVisitorBasedCodemod", "path": "src/django_autotyping/stubbing/codemods/base.py", "snippet": "class StubVisitorBasedCodemod(VisitorBasedCodemodCommand):\n \"\"\"The base class for all codemods used for custom stub files.\"\"\"\n\n STUB_FILES: ClassVar[set[str]]\n\n def __init__(self, context: CodemodContext) -> None:\n super().__init__(context)\n self.django_context = cast(\"DjangoStubbingContext\", context.scratch[\"django_context\"])\n self.stubs_settings = cast(\"StubsGenerationSettings\", context.scratch[\"stubs_settings\"])\n\n def add_model_imports(self) -> None:\n \"\"\"Add the defined models in the Django context as imports to the current file.\"\"\"\n\n # TODO LibCST should support adding imports from `ImportItem` objects\n imports = AddImportsVisitor._get_imports_from_context(self.context)\n imports.extend(self.django_context.model_imports)\n self.context.scratch[AddImportsVisitor.CONTEXT_KEY] = imports\n\n def add_typing_imports(self, names: list[str]) -> None:\n \"\"\"Add imports to the `typing` module (either from `typing` or `typing_extensions`).\"\"\"\n for name in names:\n AddImportsVisitor.add_needed_import(\n self.context,\n module=\"typing_extensions\" if name in TYPING_EXTENSIONS_NAMES else \"typing\",\n obj=name,\n )\n\n def transform_module(self, tree: cst.Module) -> cst.Module:\n # LibCST automatically runs `AddImportsVisitor` and `RemoveImportsVisitor`,\n # but this is hardcoded. So we manually add our visitor.\n tree = super().transform_module(tree)\n transform = InsertAfterImportsVisitor\n\n return self._instantiate_and_run(transform, tree)" }, { "identifier": "OVERLOAD_DECORATOR", "path": "src/django_autotyping/stubbing/codemods/constants.py", "snippet": "OVERLOAD_DECORATOR = cst.Decorator(decorator=cst.Name(\"overload\"))" }, { "identifier": "TypedDictAttribute", "path": "src/django_autotyping/stubbing/codemods/utils.py", "snippet": "class TypedDictAttribute:\n name: str\n \"\"\"The attribute name.\"\"\"\n\n annotation: str\n \"\"\"The annotation of the field.\"\"\"\n\n docstring: str | None = None\n \"\"\"The docstring of the field.\"\"\"\n\n required: bool = False\n \"\"\"Whether the field should be marked as `Required`.\"\"\"\n\n not_required: bool = False\n \"\"\"Whether the field should be marked as `NotRequired`.\"\"\"\n\n @property\n def marked_annotation(self) -> str:\n \"\"\"The annotation additionally marked as required or not required.\"\"\"\n if self.required:\n return f\"Required[{self.annotation}]\"\n if self.not_required:\n return f\"NotRequired[{self.annotation}]\"\n return self.annotation\n\n def __post_init__(self):\n if self.required and self.not_required:\n raise ValueError(\"`required` and `not_required` can't be set together.\")" }, { "identifier": "build_typed_dict", "path": "src/django_autotyping/stubbing/codemods/utils.py", "snippet": "def build_typed_dict(\n name: str, attributes: list[TypedDictAttribute], total: bool = True, leading_line: bool = False\n) -> cst.SimpleStatementLine | cst.ClassDef:\n \"\"\"Build a `TypedDict` class definition.\n\n If one of the attribute's name is not a valid Python identifier, the alternative functional syntax\n will be used (a `SimpleStatementLine` will be created instead of a `ClassDef`).\n\n Args:\n name: The name of the resulting class.\n attributes: A list of `TypedDictAttribute` instances, representing attributes of the dict.\n total: Whether `total=True` should be used.\n leadind_line: Whether an empty leading line should be added before the class definition.\n\n \"\"\"\n functional = any(not attr.name.isidentifier() for attr in attributes)\n leading_lines = [cst.EmptyLine(indent=False)] if leading_line else []\n if not functional:\n body: list[cst.SimpleStatementLine] = []\n\n for attr in attributes:\n ann_statement = helpers.parse_template_statement(f\"{attr.name}: {attr.marked_annotation}\")\n if attributes.index(attr) != 0:\n ann_statement = ann_statement.with_changes(leading_lines=[cst.EmptyLine(indent=False)])\n body.append(ann_statement)\n\n if attr.docstring:\n docstring = f'\"\"\"{_indent(attr.docstring)}\"\"\"'\n body.append(cst.SimpleStatementLine(body=[cst.Expr(cst.SimpleString(docstring))]))\n\n return cst.ClassDef(\n name=cst.Name(name),\n bases=[cst.Arg(cst.Name(\"TypedDict\"))],\n keywords=[\n cst.Arg(\n keyword=cst.Name(\"total\"),\n equal=cst.AssignEqual(cst.SimpleWhitespace(\"\"), cst.SimpleWhitespace(\"\")),\n value=cst.Name(\"False\"),\n )\n ]\n if not total\n else [],\n body=cst.IndentedBlock(body),\n leading_lines=leading_lines,\n )\n\n # If some attributes aren't Python identifiers, we use the functional form:\n # name = TypedDict(\"name\", {\"x\": int, \"y\": int})\n return cst.SimpleStatementLine(\n body=[\n cst.Assign(\n targets=[cst.AssignTarget(cst.Name(name))],\n value=cst.Call(\n func=cst.Name(\"TypedDict\"),\n args=[\n cst.Arg(cst.SimpleString(f'\"{name}\"')),\n cst.Arg(\n cst.Dict(\n elements=[\n cst.DictElement(\n key=cst.SimpleString(f'\"{attr.name}\"'), value=cst.Name(attr.marked_annotation)\n )\n for attr in attributes\n ]\n )\n ),\n ],\n ),\n )\n ],\n leading_lines=leading_lines,\n )" }, { "identifier": "get_param", "path": "src/django_autotyping/stubbing/codemods/utils.py", "snippet": "def get_param(node: cst.FunctionDef, param_name: str) -> cst.Param:\n \"\"\"Get the `Param` node matching `param_name`.\"\"\"\n try:\n return next(param for param in node.params.params if param.name.value == param_name)\n except StopIteration:\n raise RuntimeError(\n f\"The `FunctionDef` node with name {node.name.value!r} does not have any parameter named {param_name!r}\"\n )" } ]

[ { "identifier": "KubeEventType", "path": "oper8/deploy_manager/kube_event.py", "snippet": "class KubeEventType(Enum):\n \"\"\"Enum for all possible kubernetes event types\"\"\"\n\n DELETED = \"DELETED\"\n MODIFIED = \"MODIFIED\"\n ADDED = \"ADDED\"" }, { "identifier": "ReadyReason", "path": "oper8/status.py", "snippet": "class ReadyReason(Enum):\n \"\"\"Nested class to hold reason constants for the Ready condition\"\"\"\n\n # The application is stable and ready for traffic\n STABLE = \"Stable\"\n\n # The application is rolling out for the first time\n INITIALIZING = \"Initializing\"\n\n # The application rollout is in progress and will continue\n # the next reconcile\n IN_PROGRESS = \"InProgress\"\n\n # The application has hit an unrecoverable config error during rollout\n CONFIG_ERROR = \"ConfigError\"\n\n # The application has hit an unrecoverable error during rollout\n ERRORED = \"Errored\"" }, { "identifier": "make_application_status", "path": "oper8/status.py", "snippet": "def make_application_status( # pylint: disable=too-many-arguments,too-many-locals\n ready_reason: Optional[Union[ReadyReason, str]] = None,\n ready_message: str = \"\",\n updating_reason: Optional[Union[UpdatingReason, str]] = None,\n updating_message: str = \"\",\n component_state: Optional[CompletionState] = None,\n external_conditions: Optional[List[dict]] = None,\n external_status: Optional[dict] = None,\n version: Optional[str] = None,\n supported_versions: Optional[List[str]] = None,\n operator_version: Optional[str] = None,\n kind: Optional[str] = None,\n) -> dict:\n \"\"\"Create a full status object for an application\n\n Args:\n ready_reason: Optional[ReadyReason or str]\n The reason enum for the Ready condition\n ready_message: str\n Plain-text message explaining the Ready condition value\n updating_reason: Optional[UpdatingReason or str]\n The reason enum for the Updating condition\n updating_message: str\n Plain-text message explaining the Updating condition value\n component_state: Optional[CompletionState]\n The terminal state of components in the latest rollout\n external_conditions: Optional[List[dict]]\n Additional conditions to include in the update\n external_status: Optional[dict]\n Additional key/value status elements besides \"conditions\" that\n should be preserved through the update\n version: Optional[str]\n The verified version of the application\n supported_versions: Optional[List[str]]\n The list of supported versions for this application\n operator_version: Optional[str]\n The operator version for this application\n kind: Optional[str]\n The kind of reconciliing CR. If specified, this function adds\n service status field which is compliant with IBM Cloud Pak\n requirements.\n\n Returns:\n current_status: dict\n Dict representation of the status for the application\n \"\"\"\n now = datetime.now()\n conditions = []\n if ready_reason is not None:\n conditions.append(_make_ready_condition(ready_reason, ready_message, now))\n if updating_reason is not None:\n conditions.append(\n _make_updating_condition(updating_reason, updating_message, now)\n )\n conditions.extend(external_conditions or [])\n status = external_status or {}\n status[\"conditions\"] = conditions\n\n # If a component_state is given, create the top-level status elements to\n # track which components have deployed and verified\n if component_state is not None:\n log.debug2(\"Adding component state to status\")\n status[COMPONENT_STATUS] = _make_component_state(component_state)\n log.debug3(status[COMPONENT_STATUS])\n\n # Create the versions section\n if version is not None:\n nested_set(status, VERSIONS_FIELD_CURRENT_VERSION, version)\n if supported_versions is not None:\n nested_set(\n status,\n VERSIONS_FIELD_AVAILABLE_VERSIONS,\n [_make_available_version(version) for version in supported_versions],\n )\n if operator_version is not None:\n nested_set(status, OPERATOR_VERSION, operator_version)\n\n # Create service status section\n if kind:\n # make field name follow k8s naming convention\n service_status_field = kind[0].lower()\n if len(kind) > 1:\n service_status_field += kind[1:]\n service_status_field += \"Status\"\n\n # Only update service status if the current value is set by oper8. This\n # allows services to override the service status section\n current_service_status = status.get(service_status_field)\n managed_service_values = [status.value for status in ServiceStatus]\n if (\n not current_service_status\n or current_service_status in managed_service_values\n ):\n current_service_status = _make_service_status(\n ready_reason, updating_reason\n ).value\n\n status[service_status_field] = current_service_status\n\n return status" }, { "identifier": "make_managed_object", "path": "oper8/test_helpers/pwm_helpers.py", "snippet": "def make_managed_object(*args, **kwargs):\n return ManagedObject(make_resource(*args, **kwargs))" }, { "identifier": "AnnotationFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class AnnotationFilter(Filter):\n \"\"\"Filter resources to reconcile on annotation changes\"\"\"\n\n def __init__(self, resource: ManagedObject):\n \"\"\"Initialize the annotation hash variable\"\"\"\n self.annotations = None\n super().__init__(resource)\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Test if a resource's annotation has changed\"\"\"\n # Ignore Added and deleted events\n if event in [KubeEventType.ADDED, KubeEventType.DELETED]:\n return\n\n return self.annotations != self.get_annotation_hash(resource)\n\n def update(self, resource: ManagedObject):\n \"\"\"Update the currently stored annotation\"\"\"\n self.annotations = self.get_annotation_hash(resource)\n\n def get_annotation_hash(self, resource: ManagedObject) -> str:\n \"\"\"Helper function to get the annotation hash\"\"\"\n return obj_to_hash(resource.metadata.get(\"annotations\", {}))" }, { "identifier": "CreationDeletionFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class CreationDeletionFilter(Filter):\n \"\"\"Filter to ensure reconciliation on creation and deletion events\"\"\"\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Return true if event is ADDED or DELETED\"\"\"\n\n # Ignore non Added/Deleted Events\n if event not in [KubeEventType.ADDED, KubeEventType.DELETED]:\n return\n\n return True" }, { "identifier": "DependentWatchFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class DependentWatchFilter(Filter):\n \"\"\"Don't reconcile creation events as we can assume the owner created\n them\"\"\"\n\n def test(self, resource: ManagedObject, event: KubeEventType) -> Optional[bool]:\n \"\"\"Return False if event is ADDED\"\"\"\n return event != KubeEventType.ADDED" }, { "identifier": "GenerationFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class GenerationFilter(Filter):\n \"\"\"Filter for reconciling on generation changes for resources that support it\"\"\"\n\n def __init__(self, resource: ManagedObject):\n \"\"\"Set generation instance variable\"\"\"\n super().__init__(resource)\n self.generation = None\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Return true if resource generation is different than before\"\"\"\n # Only update&test resources with a generation\n if not self.generation:\n return\n\n # Only test on resource updates\n if event in [KubeEventType.ADDED, KubeEventType.DELETED]:\n return\n\n # Test if new generation is different\n return self.generation != resource.metadata.get(\"generation\")\n\n def update(self, resource: ManagedObject):\n \"\"\"Update the currently observed generation\"\"\"\n self.generation = resource.metadata.get(\"generation\")" }, { "identifier": "LabelFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class LabelFilter(Filter):\n \"\"\"Filter for resources that match a set of labels\"\"\"\n\n @abstractclassproperty\n def labels(self) -> dict:\n \"\"\"Subclasses must implement a labels class attribute\"\"\"\n\n def test(self, resource: ManagedObject, event: KubeEventType) -> Optional[bool]:\n \"\"\"Return true is a resource matches the requested labels\"\"\"\n resource_labels = resource.get(\"metadata\", {}).get(\"labels\")\n # Check to make sure every requested label matches\n return all(\n resource_labels.get(label) == value for label, value in self.labels.items()\n )" }, { "identifier": "NoGenerationFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class NoGenerationFilter(Filter):\n \"\"\"Filter for reconciling changes to spec on resources that don't support\n the generation field like pods. It does this by hashing the objects excluding\n status and metadata\"\"\"\n\n def __init__(self, resource: ManagedObject):\n \"\"\"Check if resource supports generation and initialize the hash dict\"\"\"\n self.supports_generation = resource.metadata.get(\"generation\") is not None\n self.resource_hashes = {}\n super().__init__(resource)\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Return True if a resources current hash differs from the current\"\"\"\n # Don't test resources that support generation or if we don't have hashes yet\n if self.supports_generation or not self.resource_hashes:\n return\n\n # Only test on resource updates\n if event in [KubeEventType.ADDED, KubeEventType.DELETED]:\n return\n\n # Check each stored resource hash to see if its\n # changed\n for key, obj_has in self.resource_hashes.items():\n if obj_has != obj_to_hash(resource.get(key)):\n log.debug2(\"Detected change in %s\", key)\n return True\n\n return False\n\n def update(self, resource: ManagedObject):\n \"\"\"Update the observed spec hashes\"\"\"\n if self.supports_generation:\n return\n\n # Get the default hashes for all object keys except metadata\n # and status\n for key, obj in resource.definition.items():\n if key in [\"metadata\", \"status\", \"kind\", \"apiVersion\"]:\n continue\n\n self.resource_hashes[key] = obj_to_hash(obj)" }, { "identifier": "PauseFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class PauseFilter(Filter):\n \"\"\"This filter skips resources that have the oper8 pause annotation\"\"\"\n\n def test(self, resource: ManagedObject, event: KubeEventType) -> Optional[bool]:\n \"\"\"Test if a resource has the pause annotation\"\"\"\n return not ReconcileManager._is_paused( # pylint: disable=protected-access\n resource\n )" }, { "identifier": "ResourceVersionFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class ResourceVersionFilter(Filter):\n \"\"\"Filter for duplicate resource versions which happens when restarting a\n watch connection\"\"\"\n\n def __init__(self, resource: ManagedObject):\n \"\"\"Initialize the resource version list\"\"\"\n # Use a dequeue instead of a list/set to set a bound on the number\n # of tracked versions\n self.resource_versions = deque([], maxlen=RESOURCE_VERSION_KEEP_COUNT)\n super().__init__(resource)\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Test if the resource's resourceVersion has been seen before\"\"\"\n\n # Don't skip add events as the kubernetes watch can duplicate events\n if event == KubeEventType.DELETED:\n return\n\n return resource.resource_version not in self.resource_versions\n\n def update(self, resource: ManagedObject):\n \"\"\"Add the resources ResourceVersion to the list\"\"\"\n self.resource_versions.append(resource.resource_version)" }, { "identifier": "SubsystemStatusFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class SubsystemStatusFilter(Filter):\n \"\"\"Reconcile oper8 controllers when their oper8 status changes\n\n EXPERIMENTAL: This has passed basic validation but has not been rigorously tested\n in the field\n \"\"\"\n\n def __init__(self, resource: ManagedObject):\n \"\"\"Initialize the currently observed ready condition\"\"\"\n self.ready_condition = None\n super().__init__(resource)\n\n def test( # pylint: disable=inconsistent-return-statements\n self,\n resource: ManagedObject,\n event: KubeEventType,\n ) -> Optional[bool]:\n \"\"\"Test if a resources subsystem condition has changed\"\"\"\n if event in [KubeEventType.ADDED, KubeEventType.DELETED]:\n return\n\n return self.ready_condition != get_condition(\n READY_CONDITION, resource.get(\"status\", {})\n ).get(\"reason\")\n\n def update(self, resource: ManagedObject):\n \"\"\"Update the currently observed ready condition\"\"\"\n self.ready_condition = get_condition(\n READY_CONDITION, resource.get(\"status\", {})\n ).get(\"reason\")" }, { "identifier": "UserAnnotationFilter", "path": "oper8/watch_manager/python_watch_manager/filters/filters.py", "snippet": "class UserAnnotationFilter(AnnotationFilter):\n \"\"\"Filter resources to reconcile on user annotation changes. This excludes\n kubernetes and openshift annotations\n \"\"\"\n\n def get_annotation_hash(self, resource: ManagedObject) -> str:\n \"\"\"Overriden function to exclude common platform annotations from\n the annotation hash\"\"\"\n output_annotations = {}\n for key, value in resource.metadata.get(\"annotations\", {}).items():\n if self.contains_platform_key(key):\n continue\n\n output_annotations[key] = value\n\n return obj_to_hash(output_annotations)\n\n def contains_platform_key(self, key: str) -> bool:\n \"\"\"Helper to check if the key contains one of the\n platform annotations\"\"\"\n return any(\n reserved_key in key for reserved_key in RESERVED_PLATFORM_ANNOTATIONS\n )" } ]

[ { "identifier": "AlwaysEqual", "path": "tests/common.py", "snippet": "class AlwaysEqual:\n def __eq__(self, other):\n return True" }, { "identifier": "AlwaysLarger", "path": "tests/common.py", "snippet": "class AlwaysLarger:\n def __lt__(self, other):\n return False\n\n def __le__(self, other):\n return False\n\n def __gt__(self, other):\n return True\n\n def __ge__(self, other):\n return True" }, { "identifier": "AlwaysSmaller", "path": "tests/common.py", "snippet": "class AlwaysSmaller:\n def __lt__(self, other):\n return True\n\n def __le__(self, other):\n return True\n\n def __gt__(self, other):\n return False\n\n def __ge__(self, other):\n return False" }, { "identifier": "NeverEqual", "path": "tests/common.py", "snippet": "class NeverEqual:\n def __eq__(self, other):\n return False" }, { "identifier": "local_ams_tz", "path": "tests/common.py", "snippet": "@contextmanager\ndef local_ams_tz():\n with patch.dict(os.environ, {\"TZ\": \"Europe/Amsterdam\"}):\n tzset()\n yield" }, { "identifier": "local_nyc_tz", "path": "tests/common.py", "snippet": "@contextmanager\ndef local_nyc_tz():\n with patch.dict(os.environ, {\"TZ\": \"America/New_York\"}):\n tzset()\n yield" } ]

[ { "identifier": "GPT", "path": "jarvisportal/gpt.py", "snippet": "class GPT:\n def __init__(self, assistant_id):\n self.client = OpenAI()\n # self.thread_id = self._get_or_create_thread_id() # expensive :(\n self.thread_id = self._create_thread_id()\n self.assistant_id = assistant_id\n self.last_messsage = None\n self.last_step_id = None\n self.run = None\n self._cancel_pending_runs()\n \n def _get_or_create_thread_id(self):\n threadfilename = \"./.gptexecthread\"\n if os.getenv(\"GPTEXEC_THREAD_ID\"):\n thread_id = os.getenv(\"GPTEXEC_THREAD_ID\")\n print(f\"continuing GPT thread {thread_id}\")\n return thread_id\n elif os.path.exists(threadfilename):\n with open(threadfilename, \"r\") as file:\n thread_id = file.read().strip()\n print(f\"continuing GPT thread {thread_id}\")\n return thread_id\n else:\n thread = self.client.beta.threads.create()\n with open(threadfilename, \"w\") as file:\n file.write(thread.id)\n print(f\"created GPT thread {thread.id}\")\n return thread.id\n\n def _create_thread_id(self):\n thread = self.client.beta.threads.create()\n print(f\"created GPT thread {thread.id}\")\n return thread.id\n \n def _cancel_pending_runs(self):\n pending_runs = [r for r in self.client.beta.threads.runs.list(thread_id=self.thread_id) if r.status in {\"in_progress\", \"requires_action\"}]\n for run in pending_runs:\n self.client.beta.threads.runs.cancel(thread_id=self.thread_id, run_id=run.id)\n print(f\"canceled {run.status} run {run.id}\")\n\n def send_chat(self, message):\n omessage = self.client.beta.threads.messages.create(\n thread_id=self.thread_id, role=\"user\", content=message\n )\n self.run = self.client.beta.threads.runs.create(\n thread_id=self.thread_id, assistant_id=self.assistant_id\n )\n self.last_messsage = omessage\n\n def next_answer(self):\n while self.run.status in [\"queued\", \"in_progress\"]:\n sleep(1)\n self.run = self.client.beta.threads.runs.retrieve(\n thread_id=self.thread_id, run_id=self.run.id\n )\n answer = None\n if self.run.status == \"completed\":\n messages = list(\n self.client.beta.threads.messages.list(\n thread_id=self.thread_id, before=self.last_messsage.id\n )\n )\n message = messages[0]\n answer = {\n \"type\": \"message\",\n \"messages\": [c.text.value for c in message.content],\n \"is_final\": True,\n }\n self.run = None\n elif self.run.status == \"requires_action\":\n steps = list(\n self.client.beta.threads.runs.steps.list(\n thread_id=self.thread_id,\n run_id=self.run.id,\n order=\"asc\",\n after=self.last_step_id,\n )\n )\n step = steps[0]\n if step.step_details.type != 'message_creation': # still dont quite understand, but I know it doesn have too_calls\n try:\n answer = {\"type\": \"action\", \"actions\": step.step_details.tool_calls}\n except:\n print(step)\n raise\n self.last_step_id = step.id\n elif self.run.status == \"failed\":\n message = \"RUN FAILED.\"\n if self.run.last_error:\n message = f\"{message} {self.run.last_error}\"\n print(message)\n return answer\n\n def send_action_results(self, actions, results):\n self.run = self.client.beta.threads.runs.submit_tool_outputs(\n thread_id=self.thread_id,\n run_id=self.run.id,\n tool_outputs=[\n {\"tool_call_id\": a[\"id\"], \"output\": json.dumps(r)}\n for a, r in zip(actions, results)\n ],\n )\n\n # def is_done(self, run):\n # return run.status in [\"completed\", \"failed\", \"expired\"]" }, { "identifier": "Chat", "path": "jarvisportal/llamaapichat.py", "snippet": "class Chat:\n def __init__(self, functions):\n self.messages = [\n {\"role\": \"system\", \"content\": systemprompt},\n ]\n self.functions = functions\n\n def send_chat(self, msg):\n self.messages.append({\"role\": \"user\", \"content\": msg})\n self.last_response = self._send()\n \n def next_answer(self):\n if self.last_response.get(\"function_call\"):\n answer = {\n \"type\": \"action\",\n \"is_final\": False,\n \"actions\": [{\"function\": self.last_response[\"function_call\"]}]\n }\n else:\n answer = {\n \"type\": \"message\",\n \"is_final\": True,\n \"messages\": [self.last_response[\"content\"]]\n }\n return answer\n\n def send_action_results(self, actions, results):\n self.messages.append({\"role\": \"user\", \"content\": json.dumps(results[0])})\n self.last_response = self._send()\n\n def _send(self):\n api_request_json = {\n \"model\": model,\n \"functions\": self.functions,\n \"stream\": False,\n \"messages\": self.messages,\n }\n response = llama.run(api_request_json)\n result = response.json()[\"choices\"][0][\"message\"]\n if result.get(\"function_call\"):\n fncall = result[\"function_call\"]\n self.messages.append(\n {\"role\": \"assistant\", \"content\": json.dumps(fncall)}\n )\n else:\n self.messages.append({\"role\": \"assistant\", \"content\": result[\"content\"]})\n # if self.executor and result.get(\"function_call\"):\n # fncall = result[\"function_call\"]\n # fnresult = self.executor.execute(fncall)\n # result = self.sendFnresult(fncall[\"name\"], fnresult)\n # else:\n # self.messages.append({\"role\": \"assistant\", \"content\": result[\"content\"]})\n return result" }, { "identifier": "exec_actions", "path": "jarvisportal/actions.py", "snippet": "def set_cli_input(input_stream):\n def prompt(self, path: str, content: str):\n def run(self, path: str, content: str):\ndef ActionUpdateFileLines():\n def prompt(self, path: str, line_start: int, line_end: int, content: str):\n def run(self, path: str, line_start: int, line_end: int, content: str):\n def prompt(self, path: str, start_anchor: str, end_anchor: str, content: str):\n def run(self, path: str, start_anchor: str, end_anchor: str, content: str):\n def prompt(self, path: str, old_content: str, new_content: str):\n def run(self, path: str, old_content: str, new_content: str):\n def prompt(self, command: str):\n def run(self, command):\ndef _cmdexec(cmd):\ndef exec_actions(actions, ask=False):\ndef exec_action(action, ask=False):\nclass ActionCreateFile():\nclass ActionUpdateFileAnchors():\nclass ActionUpdateFileReplace():\nclass ActionExec():\nACTIONS = {\n \"createFile\": ActionCreateFile(),\n \"updateFile_lines\": ActionUpdateFileLines(),\n \"updateFile_anchors\": ActionUpdateFileAnchors(),\n \"updateFile_replace\": ActionUpdateFileReplace(),\n \"exec\": ActionExec(),\n}" } ]